package com.sg.service.biz.component.impl;

import cn.hutool.core.date.DateUtil;
import com.sg.common.util.CommonFunctionHelper;
import com.sg.common.util.RedisUtil;
import com.sg.dto.biz.component.req.*;
import com.sg.dto.biz.component.res.*;
import com.sg.service.base.component.MCustomFields3Service;
import com.sg.service.biz.component.BusinessAtomService;
import com.sg.service.biz.component.ConfSchemeService;
import com.sg.service.biz.component.InterfaceModeService;
import com.sg.common.exception.Assert;
import com.wicket.okrcomponent.common.exception.BizException;
import org.apache.skywalking.apm.toolkit.trace.Tag;
import org.apache.skywalking.apm.toolkit.trace.Tags;
import org.apache.skywalking.apm.toolkit.trace.Trace;
import org.springframework.stereotype.Service;
import org.springframework.transaction.annotation.Transactional;

import javax.annotation.Resource;

/**
 * @author ：
 * @version 1.0
 * @date ：
 */
@Service
public class EvaCalcServiceImpl
        implements com.wicket.okrcomponent.biz.service.EvaCalcService {

    @Resource
    private RedisUtil redisUtil;
    @Resource
    private InterfaceModeService interfaceModeService;
    @Resource
    private BusinessAtomService businessAtomService;
    @Resource
    private ConfSchemeService confSchemeService;
    @Resource
    private MCustomFields3Service mCustomFields3Service;
    @Resource
    private NbEvaCalc nbEvaCalc;
//@Resource
    //private MCustomFields5Service mCustomFields5Service;

    /**
     * D2更新分段查询Redis记录(公共)[9679]
     * gen by moon at 6/23/2024, 7:08:02 AM
     */
    @Trace(operationName = "D2更新分段查询Redis记录(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public RefreshSegQueryRedisRecordComRespDto refreshSegQueryRedisRecordCom(RefreshSegQueryRedisRecordComReqDto reqDto) {


        if ((reqDto != null && reqDto.getBusinessDataSetList() != null && reqDto.getBusinessDataSetList().size() > 0)) {
            //if(D2更新分段查询Redis记录(公共).业务数据对象列表数据集条数 大于 0)  69355

            ImplementDatasSetFetchLastLatestComRespDto implementDatasSetFetchLastLatestComRespDto = null;
            ImplementDatasSetFetchLastLatestComReqDto implementDatasSetFetchLastLatestComReqDto = new ImplementDatasSetFetchLastLatestComReqDto();
            if (reqDto != null) {
                //simpleList-to-objLists
                for (String item : reqDto.getBusinessDataSetList()) {
                    BusinessDataSetDto oneItem = new BusinessDataSetDto();
                    if (reqDto != null) {
                        oneItem.setCustomField1(item);//SimpleFieldAssign//sourceId:367324_2_69356
                    }

                    implementDatasSetFetchLastLatestComReqDto.getBusinessDataSetList().add(oneItem);
                }//sourceId:1826987_1_69356
            }

            /*D2执行数据集取最后一条(公共)[9408]   */

            implementDatasSetFetchLastLatestComRespDto = interfaceModeService.implementDatasSetFetchLastLatestCom(implementDatasSetFetchLastLatestComReqDto)/*vcase invoke isSameApp*/;


            if ((reqDto != null && reqDto.getLastDataObjectId() == null)) {
                //if(D2更新分段查询Redis记录(公共).最后一条数据对象ID 值等于空 )  69357

                AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
                if (implementDatasSetFetchLastLatestComRespDto != null) {
                    AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto = new AddRedisBusinessDataSetComReqDto();
                    addRedisBusinessDataSetComReqDto.setIsDataList("FALSE");//sourceId:1827219_1_69359
                    addRedisBusinessDataSetComReqDto.setIsDeleteRedis("TRUE");//sourceId:1827216_1_69359
                    addRedisBusinessDataSetComReqDto.setDuration(Long.valueOf(2));//CUSTOM_CONVENTION//sourceId:1827217_1_69359
                    addRedisBusinessDataSetComReqDto.setTimeUnitType("HOUR");//sourceId:1827218_1_69359
                    if (reqDto != null) {
                        addRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1827211_1_69359
                        addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1827213_1_69359
                        addRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1827212_1_69359
                        addRedisBusinessDataSetComReqDto.setCustomField1(reqDto.getBusinessDataSetPrimaryKeyName());//SimpleFieldAssign//sourceId:1827214_1_69359
                    }
                    if (implementDatasSetFetchLastLatestComRespDto != null) {
                        addRedisBusinessDataSetComReqDto.setCustomFieldValue1(implementDatasSetFetchLastLatestComRespDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1827215_1_69359
                    }

                    /*D2-新增redis业务数据对象（业务原子）[8399]   */
                    Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空", false);
                    Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空", false);
                    Assert.isNull(addRedisBusinessDataSetComReqDto.getDataObjectBatchCode(), "D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-数据对象批次标识不能为空", false);
                    Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(), "D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空", false);
                    Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(), "D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-是否删除redis历史数据不能为空", false);
                    Assert.isNull(addRedisBusinessDataSetComReqDto.getDuration(), "D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-锁定时长不能为空", false);
                    Assert.isNull(addRedisBusinessDataSetComReqDto.getTimeUnitType(), "D2更新分段查询Redis记录(公共)-D2-新增redis业务数据对象（业务原子）-时间单位类型不能为空", false);
                    addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


                }
            } else if ((reqDto != null && reqDto.getLastDataObjectId() != null)) {
                //elseif(D2更新分段查询Redis记录(公共).最后一条数据对象ID 值不等于空 )  69358

                UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto = null;
                if (implementDatasSetFetchLastLatestComRespDto != null) {
                    UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto = new UpdateRedisBusinessDataSetComReqDto();
                    updateRedisBusinessDataSetComReqDto.setIsDataList("FALSE");//sourceId:1827226_1_69360
                    if (reqDto != null) {
                        updateRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1827224_1_69360
                        updateRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1827225_1_69360
                        updateRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1827223_1_69360
                        updateRedisBusinessDataSetComReqDto.setCustomField1(reqDto.getBusinessDataSetPrimaryKeyName());//SimpleFieldAssign//sourceId:1827227_1_69360
                    }
                    if (implementDatasSetFetchLastLatestComRespDto != null) {
                        updateRedisBusinessDataSetComReqDto.setCustomFieldValue1(implementDatasSetFetchLastLatestComRespDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1827228_1_69360
                    }

                    /*D2修改redis业务数据对象(业务原子)[9407]   */
                    Assert.isNull(updateRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2更新分段查询Redis记录(公共)-D2修改redis业务数据对象(业务原子)-业务数据对象不能为空", false);
                    Assert.isNull(updateRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2更新分段查询Redis记录(公共)-D2修改redis业务数据对象(业务原子)-Redis数据对象目录不能为空", false);
                    Assert.isNull(updateRedisBusinessDataSetComReqDto.getIsDataList(), "D2更新分段查询Redis记录(公共)-D2修改redis业务数据对象(业务原子)-是否是数据集对象不能为空", false);
                    updateRedisBusinessDataSetComRespDto = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


                }
            }
        }
        RefreshSegQueryRedisRecordComRespDto retData = new RefreshSegQueryRedisRecordComRespDto();


        return retData;
    }

    /**
     * D2新增规划目标计算MQ遥控器(公共)[9690]
     * gen by moon at 6/9/2024, 9:35:30 PM
     */
    @Trace(operationName = "D2新增规划目标计算MQ遥控器(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddPlanTargetCalcMqRemoteControllerComRespDto addPlanTargetCalcMqRemoteControllerCom(AddPlanTargetCalcMqRemoteControllerComReqDto reqDto) {


        //virtualUsage M2接收入参字段  69467
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        receptionServiceReq.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1834890_1_69467
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831279_1_69467
            receptionServiceReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1831280_1_69467
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1831278_1_69467
        }

        /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D2新增规划目标计算MQ遥控器(公共)-M2接收入参字段-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationSubjectId(), "D2新增规划目标计算MQ遥控器(公共)-M2接收入参字段-冗余评价主题ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D2新增规划目标计算MQ遥控器(公共)-M2接收入参字段-创建于空间ID不能为空", false);
        Assert.isNull(receptionServiceReq.getOperateTime(), "D2新增规划目标计算MQ遥控器(公共)-M2接收入参字段-操作时间不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//virtualUsage D2系统当前操作时间  69750
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
        ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto = new ImplementTimeFormatConversionComReqDto();
        if (receptionServiceRes != null) {
            implementTimeFormatConversionComReqDto.setComTxtField(receptionServiceRes.getOperateTime() != null ? String.valueOf(receptionServiceRes.getOperateTime()) : "");//SimpleFieldAssign//sourceId:1855409_1_69750
        }

        /*D2系统当前操作时间[9757]   */
        Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(), "D2新增规划目标计算MQ遥控器(公共)-D2系统当前操作时间-通用文本字段不能为空", false);
        implementTimeFormatConversionComRespDto = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）  69490
        QuerySingleRemoteControllerRedisDetailComRespDto querySingleRemoteControllerRedisDetailComRespDto = null;
        QuerySingleRemoteControllerRedisDetailComReqDto querySingleRemoteControllerRedisDetailComReqDto = new QuerySingleRemoteControllerRedisDetailComReqDto();
        querySingleRemoteControllerRedisDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1839420_1_69490
        querySingleRemoteControllerRedisDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839421_1_69490
        querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839422_1_69490
        querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField2("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1861431_1_69490
        querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue2("PLAN_TARGET_CALC");//CUSTOM_CONVENTION//sourceId:1861432_1_69490
        if (reqDto != null) {
            querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839423_1_69490
        }

        /*D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）[9708]   */
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getBusinessDataObject(), "D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-业务数据对象不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRedisDataObjectCatalogue(), "D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-Redis数据对象目录不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField1(), "D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-入参自定义字段1不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue1(), "D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-入参自定义字段值1不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField2(), "D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-入参自定义字段2不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue2(), "D2新增规划目标计算MQ遥控器(公共)-D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）-入参自定义字段值2不能为空", false);
        querySingleRemoteControllerRedisDetailComRespDto = querySingleRemoteControllerRedisDetailCom(querySingleRemoteControllerRedisDetailComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((querySingleRemoteControllerRedisDetailComRespDto != null && querySingleRemoteControllerRedisDetailComRespDto.getEvaluationTemplateId() == null)) {
            //if(D2查询规划目标计算遥控器MQRedis（用于判断是否已存在）.评价模板ID 值等于空 )  69426

            ImplementPreEvaTempConfEntParameterComRespDto implementPreEvaTempConfEntParameterComRespDto = null;
            ImplementPreEvaTempConfEntParameterComReqDto implementPreEvaTempConfEntParameterComReqDto = new ImplementPreEvaTempConfEntParameterComReqDto();
            if (reqDto != null) {
                implementPreEvaTempConfEntParameterComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831223_1_69428
                implementPreEvaTempConfEntParameterComReqDto.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1831224_1_69428
                implementPreEvaTempConfEntParameterComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1831225_1_69428
            }

            /*D2准备评价模板配置入参(公共)[8567]   */
            Assert.isNull(implementPreEvaTempConfEntParameterComReqDto.getEvaluationTemplateId(), "D2新增规划目标计算MQ遥控器(公共)-D2准备评价模板配置入参(公共)-评价模板ID不能为空", false);
            Assert.isNull(implementPreEvaTempConfEntParameterComReqDto.getEvaluationSubjectId(), "D2新增规划目标计算MQ遥控器(公共)-D2准备评价模板配置入参(公共)-评价主题ID不能为空", false);
            Assert.isNull(implementPreEvaTempConfEntParameterComReqDto.getSpaceId(), "D2新增规划目标计算MQ遥控器(公共)-D2准备评价模板配置入参(公共)-创建于空间ID不能为空", false);
            implementPreEvaTempConfEntParameterComRespDto = confSchemeService.implementPreEvaTempConfEntParameterCom(implementPreEvaTempConfEntParameterComReqDto)/*vcase invoke isSameApp*/;


            AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
            if (implementTimeFormatConversionComRespDto != null && implementPreEvaTempConfEntParameterComRespDto != null) {
                AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto = new AddRedisBusinessDataSetComReqDto();
                addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831198_1_69427
                addRedisBusinessDataSetComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1831095_1_69427
                addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1831197_1_69427
                addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1831094_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1831096_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1831098_1_69427
                addRedisBusinessDataSetComReqDto.setCustomFieldValue2("0");//CUSTOM_CONVENTION//sourceId:1831099_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1831100_1_69427
                addRedisBusinessDataSetComReqDto.setCustomFieldValue3("0");//CUSTOM_CONVENTION//sourceId:1831101_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1831419_1_69427
                addRedisBusinessDataSetComReqDto.setCustomFieldValue4("FALSE");//CUSTOM_CONVENTION//sourceId:1831420_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField5("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1831421_1_69427
                addRedisBusinessDataSetComReqDto.setCustomFieldValue5("PLAN_TARGET_CALC");//CUSTOM_CONVENTION//sourceId:1831105_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1831106_1_69427
                addRedisBusinessDataSetComReqDto.setCustomFieldValue6(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1831107_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1831108_1_69427
                // TODO: 2024/6/2
                addRedisBusinessDataSetComReqDto.setCustomFieldValue7(DateUtil.format(receptionServiceRes.getOperateTime(), "yyyy-MM-dd HH:mm:ss"));//CURRENT_DATE
                addRedisBusinessDataSetComReqDto.setCustomField8("isAllowBudgetOverruns");//CUSTOM_CONVENTION//sourceId:1831110_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField9("cashAccountUnit");//CUSTOM_CONVENTION//sourceId:1831112_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField10("isOpenFinance");//CUSTOM_CONVENTION//sourceId:1831114_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField11("schemeDataPara");//CUSTOM_CONVENTION//sourceId:1831116_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField12("isOkrPlanScene");//CUSTOM_CONVENTION//sourceId:1831118_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField13("reportType");//CUSTOM_CONVENTION//sourceId:1831120_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField14("cycleMode");//CUSTOM_CONVENTION//sourceId:1831122_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField15("fatherCycleType");//CUSTOM_CONVENTION//sourceId:1831124_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField16("subcycleType");//CUSTOM_CONVENTION//sourceId:1831126_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField17("midCycleType");//CUSTOM_CONVENTION//sourceId:1831128_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField18("openMidCycle");//CUSTOM_CONVENTION//sourceId:1831130_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField19("lastCycleType");//CUSTOM_CONVENTION//sourceId:1831132_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField20("secondLastCycleType");//CUSTOM_CONVENTION//sourceId:1831134_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField21("isOpenMidProcess");//CUSTOM_CONVENTION//sourceId:1831136_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField22("processMidCycleType");//CUSTOM_CONVENTION//sourceId:1831138_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField23("isOpenSubReportLimit");//CUSTOM_CONVENTION//sourceId:1831140_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField24("constTaskIsOpenReport");//CUSTOM_CONVENTION//sourceId:1831142_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField25("constIsOpenAtuoReport");//CUSTOM_CONVENTION//sourceId:1831144_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField26("noPracticalValueObjIsProgReport");//CUSTOM_CONVENTION//sourceId:1831146_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField27("actualScoreIsOpenLocalLevelScore");//CUSTOM_CONVENTION//sourceId:1831148_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField28("objectiveActualScoreIsOpenLocalLevelScore");//CUSTOM_CONVENTION//sourceId:1831150_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField29("actualScoreFormula");//CUSTOM_CONVENTION//sourceId:1831152_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField30("subjectiveRatingTotalValue");//CUSTOM_CONVENTION//sourceId:1831154_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField31("subjectiveFullMarkUnit");//CUSTOM_CONVENTION//sourceId:1831156_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField32("scoreDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831158_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField33("degreeDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831160_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField34("progressDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831162_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField35("subjectiveScorePoint");//CUSTOM_CONVENTION//sourceId:1831164_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField36("weightPoint");//CUSTOM_CONVENTION//sourceId:1831166_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField37("weightDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831168_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField38("increasesDropDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831170_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField39("actualValueDecimalPoint");//CUSTOM_CONVENTION//sourceId:1831172_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField40("decimalDigitsLastRules");//CUSTOM_CONVENTION//sourceId:1831174_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField41("subjectiveScoreWeight");//CUSTOM_CONVENTION//sourceId:1831176_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField42("objectiveScoreWeight");//CUSTOM_CONVENTION//sourceId:1831178_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField43("processReportScoreMidWeight");//CUSTOM_CONVENTION//sourceId:1831180_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField44("processReportScoreProMidWeight");//CUSTOM_CONVENTION//sourceId:1831182_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField45("processReportScoreAvgWeight");//CUSTOM_CONVENTION//sourceId:1831184_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField46("reportScoreSubAndObjWeight");//CUSTOM_CONVENTION//sourceId:1831186_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField47("actualScoreLocalLevelWeight");//CUSTOM_CONVENTION//sourceId:1831188_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField48("actualScoreLowerLevelWeight");//CUSTOM_CONVENTION//sourceId:1831190_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField49("isOpenSymbolicAchievements");//CUSTOM_CONVENTION//sourceId:1831192_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField50("isOpenBudget");//CUSTOM_CONVENTION//sourceId:1834500_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField51("isOpenBudgetReport");//CUSTOM_CONVENTION//sourceId:1834713_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField52("useAccountSubjectType");//CUSTOM_CONVENTION//sourceId:1834715_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField53("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:1834717_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField54("isAllowBudgetOverruns");//CUSTOM_CONVENTION//sourceId:1834719_1_69427
                addRedisBusinessDataSetComReqDto.setCustomField55("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:1837489_1_69427
                if (reqDto != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831097_1_69427
                }
                if (implementTimeFormatConversionComRespDto != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue7(implementTimeFormatConversionComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1831109_1_69427
                }
                if (implementPreEvaTempConfEntParameterComRespDto != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue8(implementPreEvaTempConfEntParameterComRespDto.getIsAllowBudgetOverruns());//SimpleFieldAssign//sourceId:1831111_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue9(implementPreEvaTempConfEntParameterComRespDto.getCashAccountUnit());//SimpleFieldAssign//sourceId:1831113_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue10(implementPreEvaTempConfEntParameterComRespDto.getIsOpenFinance());//SimpleFieldAssign//sourceId:1831115_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue11(implementPreEvaTempConfEntParameterComRespDto.getSchemeDataPara());//SimpleFieldAssign//sourceId:1831117_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue12(implementPreEvaTempConfEntParameterComRespDto.getIsOkrPlanScene());//SimpleFieldAssign//sourceId:1831119_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue13(implementPreEvaTempConfEntParameterComRespDto.getReportType());//SimpleFieldAssign//sourceId:1831121_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue14(implementPreEvaTempConfEntParameterComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1831123_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue15(implementPreEvaTempConfEntParameterComRespDto.getFatherCycleType());//SimpleFieldAssign//sourceId:1831125_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue16(implementPreEvaTempConfEntParameterComRespDto.getSubcycleType());//SimpleFieldAssign//sourceId:1831127_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue17(implementPreEvaTempConfEntParameterComRespDto.getMidCycleType());//SimpleFieldAssign//sourceId:1831129_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue18(implementPreEvaTempConfEntParameterComRespDto.getOpenMidCycle());//SimpleFieldAssign//sourceId:1831131_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue19(implementPreEvaTempConfEntParameterComRespDto.getLastCycleType());//SimpleFieldAssign//sourceId:1831133_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue20(implementPreEvaTempConfEntParameterComRespDto.getSecondLastCycleType());//SimpleFieldAssign//sourceId:1831135_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue21(implementPreEvaTempConfEntParameterComRespDto.getIsOpenMidProcess());//SimpleFieldAssign//sourceId:1831137_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue22(implementPreEvaTempConfEntParameterComRespDto.getProcessMidCycleType());//SimpleFieldAssign//sourceId:1831139_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue23(implementPreEvaTempConfEntParameterComRespDto.getIsOpenSubReportLimit());//SimpleFieldAssign//sourceId:1831141_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue24(implementPreEvaTempConfEntParameterComRespDto.getConstTaskIsOpenReport());//SimpleFieldAssign//sourceId:1831143_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue25(implementPreEvaTempConfEntParameterComRespDto.getConstIsOpenAtuoReport());//SimpleFieldAssign//sourceId:1831145_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue26(implementPreEvaTempConfEntParameterComRespDto.getNoPracticalValueObjIsProgReport());//SimpleFieldAssign//sourceId:1831147_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue27(implementPreEvaTempConfEntParameterComRespDto.getActualScoreIsOpenLocalLevelScore());//SimpleFieldAssign//sourceId:1831149_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue28(implementPreEvaTempConfEntParameterComRespDto.getObjectiveActualScoreIsOpenLocalLevelScore());//SimpleFieldAssign//sourceId:1831151_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue29(implementPreEvaTempConfEntParameterComRespDto.getActualScoreFormula());//SimpleFieldAssign//sourceId:1831153_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue30(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveRatingTotalValue() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveRatingTotalValue()) : "");//SimpleFieldAssign//sourceId:1831155_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue31(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveFullMarkUnit());//SimpleFieldAssign//sourceId:1831157_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue32(implementPreEvaTempConfEntParameterComRespDto.getScoreDecimalPoint() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getScoreDecimalPoint()) : "");//SimpleFieldAssign//sourceId:1831159_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue33(implementPreEvaTempConfEntParameterComRespDto.getDegreeDecimalPoint() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getDegreeDecimalPoint()) : "");//SimpleFieldAssign//sourceId:1831161_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue34(implementPreEvaTempConfEntParameterComRespDto.getProgressDecimalPoint() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProgressDecimalPoint()) : "");//SimpleFieldAssign//sourceId:1831163_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue35(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScorePoint() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScorePoint()) : "");//SimpleFieldAssign//sourceId:1831165_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue36(implementPreEvaTempConfEntParameterComRespDto.getWeightPoint());//SimpleFieldAssign//sourceId:1831167_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue37(implementPreEvaTempConfEntParameterComRespDto.getWeightDecimalPoint());//SimpleFieldAssign//sourceId:1831169_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue38(implementPreEvaTempConfEntParameterComRespDto.getIncreasesDropDecimalPoint());//SimpleFieldAssign//sourceId:1831171_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue39(implementPreEvaTempConfEntParameterComRespDto.getActualValueDecimalPoint() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getActualValueDecimalPoint()) : "");//SimpleFieldAssign//sourceId:1831173_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue40(implementPreEvaTempConfEntParameterComRespDto.getDecimalDigitsLastRules());//SimpleFieldAssign//sourceId:1831175_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue41(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScoreWeight() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getSubjectiveScoreWeight()) : "");//SimpleFieldAssign//sourceId:1831177_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue42(implementPreEvaTempConfEntParameterComRespDto.getObjectiveScoreWeight() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getObjectiveScoreWeight()) : "");//SimpleFieldAssign//sourceId:1831179_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue43(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreMidWeight() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreMidWeight()) : "");//SimpleFieldAssign//sourceId:1831181_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue44(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreProMidWeight() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreProMidWeight()) : "");//SimpleFieldAssign//sourceId:1831183_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue45(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreAvgWeight() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getProcessReportScoreAvgWeight()) : "");//SimpleFieldAssign//sourceId:1831185_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue46(implementPreEvaTempConfEntParameterComRespDto.getReportScoreSubAndObjWeight() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getReportScoreSubAndObjWeight()) : "");//SimpleFieldAssign//sourceId:1831187_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue47(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLocalLevelWeight() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLocalLevelWeight()) : "");//SimpleFieldAssign//sourceId:1831189_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue48(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLowerLevelWeight() != null ? String.valueOf(implementPreEvaTempConfEntParameterComRespDto.getActualScoreLowerLevelWeight()) : "");//SimpleFieldAssign//sourceId:1831191_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue49(implementPreEvaTempConfEntParameterComRespDto.getIsOpenSymbolicAchievements());//SimpleFieldAssign//sourceId:1831193_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue50(implementPreEvaTempConfEntParameterComRespDto.getIsOpenBudget());//SimpleFieldAssign//sourceId:1834501_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue51(implementPreEvaTempConfEntParameterComRespDto.getIsOpenBudgetReport());//SimpleFieldAssign//sourceId:1834714_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue52(implementPreEvaTempConfEntParameterComRespDto.getUseAccountSubjectType());//SimpleFieldAssign//sourceId:1834716_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue53(implementPreEvaTempConfEntParameterComRespDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:1834718_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue54(implementPreEvaTempConfEntParameterComRespDto.getIsAllowBudgetOverruns());//SimpleFieldAssign//sourceId:1834720_1_69427
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue55(implementPreEvaTempConfEntParameterComRespDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:1837490_1_69427
                }

                /*D2增规划目标计算MQ遥控器Redis（公共）[8399]   */
                Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-Redis数据对象目录不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-业务数据对象不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-是否删除redis历史数据不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-是否是数据集对象不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段1不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值1不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段2不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值2不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段3不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值3不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段4不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值4不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段5不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值5不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段6不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值6不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段7不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值7不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段8不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段9不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField10(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段10不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField11(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段11不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue11(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值11不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField12(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段12不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField13(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段13不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue13(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值13不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField14(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段14不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue14(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值14不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField15(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段15不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue15(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值15不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField16(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段16不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue16(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值16不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField17(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段17不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField18(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段18不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue18(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值18不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField19(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段19不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue19(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值19不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField20(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段20不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField21(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段21不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue21(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值21不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField22(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段22不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField23(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段23不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue23(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值23不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField24(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段24不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue24(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值24不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField25(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段25不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue25(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值25不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField26(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段26不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue26(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值26不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField27(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段27不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue27(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值27不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField28(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段28不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue28(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值28不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField29(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段29不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField30(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段30不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField31(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段31不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField32(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段32不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField33(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段33不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField34(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段34不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField35(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段35不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField36(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段36不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue36(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值36不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField37(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段37不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue37(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值37不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField38(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段38不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue38(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值38不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField39(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段39不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue39(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值39不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField40(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段40不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue40(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值40不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField41(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段41不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue41(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值41不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField42(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段42不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue42(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值42不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField43(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段43不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue43(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值43不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField44(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段44不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue44(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值44不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField45(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段45不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue45(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值45不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField46(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段46不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue46(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值46不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField47(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段47不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue47(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值47不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField48(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段48不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue48(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值48不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField49(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段49不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue49(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值49不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField50(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段50不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue50(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值50不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField51(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段51不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue51(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值51不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField52(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段52不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue52(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值52不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField53(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段53不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue53(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值53不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField54(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段54不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue54(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值54不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField55(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段55不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue55(), "D2新增规划目标计算MQ遥控器(公共)-D2增规划目标计算MQ遥控器Redis（公共）-自定义字段值55不能为空", false);
                addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


            }
        }
        AddPlanTargetCalcMqRemoteControllerComRespDto retData = new AddPlanTargetCalcMqRemoteControllerComRespDto();


        return retData;
    }

    /**
     * D2新增规划财务MQ遥控器(公共)[9691]
     * gen by moon at 7/2/2024, 3:20:02 AM
     */
    @Trace(operationName = "D2新增规划财务MQ遥控器(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddFinancialPlannMqRemoteControllerComRespDto addFinancialPlannMqRemoteControllerCom(AddFinancialPlannMqRemoteControllerComReqDto reqDto) {


        //virtualUsage M2接收入参字段  69468
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        receptionServiceReq.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1834892_1_69468
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1833017_1_69468
            receptionServiceReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834530_1_69468
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1834531_1_69468
        }

        /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D2新增规划财务MQ遥控器(公共)-M2接收入参字段-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationSubjectId(), "D2新增规划财务MQ遥控器(公共)-M2接收入参字段-冗余评价主题ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D2新增规划财务MQ遥控器(公共)-M2接收入参字段-创建于空间ID不能为空", false);
        Assert.isNull(receptionServiceReq.getOperateTime(), "D2新增规划财务MQ遥控器(公共)-M2接收入参字段-操作时间不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//virtualUsage D2系统当前操作时间  69872
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
        ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto = new ImplementTimeFormatConversionComReqDto();
        if (receptionServiceRes != null) {
            implementTimeFormatConversionComReqDto.setComTxtField(receptionServiceRes.getOperateTime() != null ? String.valueOf(receptionServiceRes.getOperateTime()) : "");//SimpleFieldAssign//sourceId:1861435_1_69872
        }

        /*D2系统当前操作时间[9757]   */
        Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(), "D2新增规划财务MQ遥控器(公共)-D2系统当前操作时间-通用文本字段不能为空", false);
        implementTimeFormatConversionComRespDto = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage D2查询规划财务MQ遥控器Redis（用于判断是否已存在）  69489
        QuerySingleRemoteControllerRedisDetailComRespDto querySingleRemoteControllerRedisDetailComRespDto = null;
        QuerySingleRemoteControllerRedisDetailComReqDto querySingleRemoteControllerRedisDetailComReqDto = new QuerySingleRemoteControllerRedisDetailComReqDto();
        querySingleRemoteControllerRedisDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839416_1_69489
        querySingleRemoteControllerRedisDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1839415_1_69489
        querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839417_1_69489
        querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField2("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1861433_1_69489
        querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue2("FINANCIAL_PLAN");//CUSTOM_CONVENTION//sourceId:1861434_1_69489
        if (reqDto != null) {
            querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839418_1_69489
        }

        /*D2查询规划财务MQ遥控器Redis（用于判断是否已存在）[9708]   */
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRedisDataObjectCatalogue(), "D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-Redis数据对象目录不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getBusinessDataObject(), "D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-业务数据对象不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField1(), "D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-入参自定义字段1不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue1(), "D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-入参自定义字段值1不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField2(), "D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-入参自定义字段2不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue2(), "D2新增规划财务MQ遥控器(公共)-D2查询规划财务MQ遥控器Redis（用于判断是否已存在）-入参自定义字段值2不能为空", false);
        querySingleRemoteControllerRedisDetailComRespDto = querySingleRemoteControllerRedisDetailCom(querySingleRemoteControllerRedisDetailComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((querySingleRemoteControllerRedisDetailComRespDto != null && querySingleRemoteControllerRedisDetailComRespDto.getEvaluationTemplateId() == null)) {
            //if(D2查询规划财务MQ遥控器Redis（用于判断是否已存在）.评价模板ID 值等于空 )  69450

            PreparationStatisticalFundSourcesAccountConfParametersComRespDto preparationStatisticalFundSourcesAccountConfParametersComRespDto = null;
            PreparationStatisticalFundSourcesAccountConfParametersComReqDto preparationStatisticalFundSourcesAccountConfParametersComReqDto = new PreparationStatisticalFundSourcesAccountConfParametersComReqDto();
            if (reqDto != null) {
                preparationStatisticalFundSourcesAccountConfParametersComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834504_1_69458
                preparationStatisticalFundSourcesAccountConfParametersComReqDto.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834505_1_69458
                preparationStatisticalFundSourcesAccountConfParametersComReqDto.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1834506_1_69458
            }

            /*D2准备统计资金来源及账户配置参数(公共)[9701]   */
            Assert.isNull(preparationStatisticalFundSourcesAccountConfParametersComReqDto.getEvaluationTemplateId(), "D2新增规划财务MQ遥控器(公共)-D2准备统计资金来源及账户配置参数(公共)-冗余评价模板ID不能为空", false);
            Assert.isNull(preparationStatisticalFundSourcesAccountConfParametersComReqDto.getEvaluationSubjectId(), "D2新增规划财务MQ遥控器(公共)-D2准备统计资金来源及账户配置参数(公共)-冗余评价主题ID不能为空", false);
            Assert.isNull(preparationStatisticalFundSourcesAccountConfParametersComReqDto.getSpaceId(), "D2新增规划财务MQ遥控器(公共)-D2准备统计资金来源及账户配置参数(公共)-创建于空间ID不能为空", false);
            preparationStatisticalFundSourcesAccountConfParametersComRespDto = preparationStatisticalFundSourcesAccountConfParametersCom(preparationStatisticalFundSourcesAccountConfParametersComReqDto)/*vcase invoke 同服务,同domain*/;


            AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
            if (implementTimeFormatConversionComRespDto != null && preparationStatisticalFundSourcesAccountConfParametersComRespDto != null) {
                AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto = new AddRedisBusinessDataSetComReqDto();
                addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1833020_1_69451
                addRedisBusinessDataSetComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1833019_1_69451
                addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1833021_1_69451
                addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1833022_1_69451
                addRedisBusinessDataSetComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1833023_1_69451
                addRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1833025_1_69451
                addRedisBusinessDataSetComReqDto.setCustomFieldValue2("0");//CUSTOM_CONVENTION//sourceId:1833026_1_69451
                addRedisBusinessDataSetComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1833027_1_69451
                addRedisBusinessDataSetComReqDto.setCustomFieldValue3("0");//CUSTOM_CONVENTION//sourceId:1833028_1_69451
                addRedisBusinessDataSetComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1834514_1_69451
                addRedisBusinessDataSetComReqDto.setCustomFieldValue4("FALSE");//CUSTOM_CONVENTION//sourceId:1834515_1_69451
                addRedisBusinessDataSetComReqDto.setCustomField5("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1834516_1_69451
                addRedisBusinessDataSetComReqDto.setCustomFieldValue5("FINANCIAL_PLAN");//CUSTOM_CONVENTION//sourceId:1834517_1_69451
                addRedisBusinessDataSetComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1834518_1_69451
                addRedisBusinessDataSetComReqDto.setCustomFieldValue6(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1834519_1_69451
                addRedisBusinessDataSetComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1834520_1_69451
                addRedisBusinessDataSetComReqDto.setCustomField8("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:1834522_1_69451
                addRedisBusinessDataSetComReqDto.setCustomField9("cashAccountUnit");//CUSTOM_CONVENTION//sourceId:1834524_1_69451
                addRedisBusinessDataSetComReqDto.setCustomField10("cycleMode");//CUSTOM_CONVENTION//sourceId:1915675_1_69451
                if (reqDto != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1833024_1_69451
                }
                if (implementTimeFormatConversionComRespDto != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue7(implementTimeFormatConversionComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1834521_1_69451
                }
                if (preparationStatisticalFundSourcesAccountConfParametersComRespDto != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue8(preparationStatisticalFundSourcesAccountConfParametersComRespDto.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:1834523_1_69451
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue9(preparationStatisticalFundSourcesAccountConfParametersComRespDto.getFundUnit());//SimpleFieldAssign//sourceId:1834525_1_69451
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue10(preparationStatisticalFundSourcesAccountConfParametersComRespDto.getCycleMode());//SimpleFieldAssign//sourceId:1915676_1_69451
                }

                /*D2增规划财务MQ遥控器Redis[8399]   */
                Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-Redis数据对象目录不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-业务数据对象不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-是否删除redis历史数据不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-是否是数据集对象不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段1不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值1不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段2不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值2不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段3不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值3不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段4不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值4不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段5不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值5不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段6不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值6不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段7不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值7不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段8不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值8不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段9不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值9不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField10(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段10不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue10(), "D2新增规划财务MQ遥控器(公共)-D2增规划财务MQ遥控器Redis-自定义字段值10不能为空", false);
                addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


            }
        }
        AddFinancialPlannMqRemoteControllerComRespDto retData = new AddFinancialPlannMqRemoteControllerComRespDto();


        return retData;
    }

    /**
     * D2遥控器MQ排队(修改单条redis)[9693]
     * gen by moon at 12/3/2024, 10:54:03 AM
     */
    @Trace(operationName = "D2遥控器MQ排队(修改单条redis)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public UpdateRemoteControllerMqQueueComRespDto updateRemoteControllerMqQueueCom(UpdateRemoteControllerMqQueueComReqDto reqDto) {


        ImplementTenReceivingFieldRespDto receptionServiceRes_3 = null;
//virtualUsage D2查评价模板的排队最小值与排队最大值  69429
        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
        QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto = new QueryRefRedisBusinessDataSetDetailComReqDto();
        queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831675_1_69429
        queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1831677_1_69429
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1831680_1_69429
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1831824_1_69429
        if (reqDto != null) {
            queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1831674_1_69429
            queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831678_1_69429
        }

        /*D2查评价模板的排队最小值与排队最大值[8476]   */
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-Redis数据对象目录不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-业务数据对象不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(), "D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-入参自定义字段1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(), "D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-入参自定义字段值1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(), "D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-自定义字段2不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(), "D2遥控器MQ排队(修改单条redis)-D2查评价模板的排队最小值与排队最大值-自定义字段3不能为空", false);
        queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


//virtualUsage M2接收排队最小值排队最大值  69566
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        if (queryRefRedisBusinessDataSetDetailComRespDto != null) {
            ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
            if (queryRefRedisBusinessDataSetDetailComRespDto != null) {
                receptionServiceReq.setQueueMinimum(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2() != null ? Integer.valueOf(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2()) : null);//SimpleFieldAssign//sourceId:1847354_1_69566
                receptionServiceReq.setQueueMaximum(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField3() != null ? Integer.valueOf(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField3()) : null);//SimpleFieldAssign//sourceId:1847355_1_69566
            }

            /*M2接收排队最小值排队最大值[8782]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq.getQueueMinimum(), "D2遥控器MQ排队(修改单条redis)-M2接收排队最小值排队最大值-排队最小值不能为空", false);
            Assert.isNull(receptionServiceReq.getQueueMaximum(), "D2遥控器MQ排队(修改单条redis)-M2接收排队最小值排队最大值-排队最大值不能为空", false);
            receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


        }
        if ((receptionServiceRes != null && receptionServiceRes.getQueueMinimum() != null && receptionServiceRes != null && receptionServiceRes.getQueueMaximum() != null)) {
            //if((M2接收原始排队最小值排队最大值.排队最小值 值不等于空  and M2接收原始排队最小值排队最大值.排队最大值 值不等于空 ))  69430

            ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeComRespDto = null;
            ImplementNumericalContrastMagnitudeComReqDto implementNumericalContrastMagnitudeComReqDto = new ImplementNumericalContrastMagnitudeComReqDto();
            if (receptionServiceRes != null) {
                implementNumericalContrastMagnitudeComReqDto.setCalcPara1(receptionServiceRes.getQueueMinimum() != null ? Double.valueOf(receptionServiceRes.getQueueMinimum()) : null);//SimpleFieldAssign//sourceId:1832076_1_69436
                implementNumericalContrastMagnitudeComReqDto.setCalcPara2(receptionServiceRes.getQueueMaximum() != null ? Double.valueOf(receptionServiceRes.getQueueMaximum()) : null);//SimpleFieldAssign//sourceId:1832077_1_69436
            }

            /*D2排队最小值与排队最大值比较[5551]   */
            Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara1(), "D2遥控器MQ排队(修改单条redis)-D2排队最小值与排队最大值比较-计算入参1不能为空", false);
            Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara2(), "D2遥控器MQ排队(修改单条redis)-D2排队最小值与排队最大值比较-计算入参2不能为空", false);
            implementNumericalContrastMagnitudeComRespDto = interfaceModeService.implementNumericalContrastMagnitudeCom(implementNumericalContrastMagnitudeComReqDto)/*vcase invoke isSameApp*/;


            if ((receptionServiceRes != null && receptionServiceRes.getQueueMinimum() == 0L && receptionServiceRes != null && receptionServiceRes.getQueueMaximum() == 0L)) {
                //if((M2接收原始排队最小值排队最大值.排队最小值 等于 0 and M2接收原始排队最小值排队最大值.排队最大值 等于 0))  69437

                CalculateAdditionOfTwoNumsComRespDto calculateAdditionOfTwoNumsComRespDto = null;
                CalculateAdditionOfTwoNumsComReqDto calculateAdditionOfTwoNumsComReqDto = new CalculateAdditionOfTwoNumsComReqDto();
                calculateAdditionOfTwoNumsComReqDto.setCalcPara2(Double.valueOf("1"));//CUSTOM_CONVENTION//sourceId:1834732_1_69464
                if (receptionServiceRes != null) {
                    calculateAdditionOfTwoNumsComReqDto.setCalcPara1(receptionServiceRes.getQueueMinimum() != null ? Double.valueOf(receptionServiceRes.getQueueMinimum()) : null);//SimpleFieldAssign//sourceId:1834731_1_69464
                }

                /*D2排队最小值+1[8137]   */
                Assert.isNull(calculateAdditionOfTwoNumsComReqDto.getCalcPara1(), "D2遥控器MQ排队(修改单条redis)-D2排队最小值+1-计算入参1不能为空", false);
                Assert.isNull(calculateAdditionOfTwoNumsComReqDto.getCalcPara2(), "D2遥控器MQ排队(修改单条redis)-D2排队最小值+1-计算入参2不能为空", false);
                calculateAdditionOfTwoNumsComRespDto = interfaceModeService.calculateAdditionOfTwoNumsCom(calculateAdditionOfTwoNumsComReqDto)/*vcase invoke isSameApp*/;


                CalculateAdditionOfTwoNumsComRespDto calculateAdditionOfTwoNumsComRespDto_2 = null;
                CalculateAdditionOfTwoNumsComReqDto calculateAdditionOfTwoNumsComReqDto_1 = new CalculateAdditionOfTwoNumsComReqDto();
                calculateAdditionOfTwoNumsComReqDto_1.setCalcPara2(Double.valueOf("1"));//CUSTOM_CONVENTION//sourceId:1834735_1_69465
                if (receptionServiceRes != null) {
                    calculateAdditionOfTwoNumsComReqDto_1.setCalcPara1(receptionServiceRes.getQueueMaximum() != null ? Double.valueOf(receptionServiceRes.getQueueMaximum()) : null);//SimpleFieldAssign//sourceId:1834734_1_69465
                }

                /*D2排队最大值+1[8137]   */
                Assert.isNull(calculateAdditionOfTwoNumsComReqDto_1.getCalcPara1(), "D2遥控器MQ排队(修改单条redis)-D2排队最大值+1-计算入参1不能为空", false);
                Assert.isNull(calculateAdditionOfTwoNumsComReqDto_1.getCalcPara2(), "D2遥控器MQ排队(修改单条redis)-D2排队最大值+1-计算入参2不能为空", false);
                calculateAdditionOfTwoNumsComRespDto_2 = interfaceModeService.calculateAdditionOfTwoNumsCom(calculateAdditionOfTwoNumsComReqDto_1)/*vcase invoke isSameApp*/;


//ModelCode: receptionService
                ImplementTenReceivingFieldRespDto receptionServiceRes_2 = null;
                if (calculateAdditionOfTwoNumsComRespDto != null && calculateAdditionOfTwoNumsComRespDto_2 != null) {
                    ImplementTenReceivingFieldReqDto receptionServiceReq_1 = new ImplementTenReceivingFieldReqDto();
                    if (receptionServiceRes != null) {
                        receptionServiceReq_1.setQueueMinimumOri(receptionServiceRes.getQueueMinimum());//SimpleFieldAssign//sourceId:1832224_1_69717
                        receptionServiceReq_1.setQueueMaximumOri(receptionServiceRes.getQueueMaximum());//SimpleFieldAssign//sourceId:1832225_1_69717
                    }
                    if (calculateAdditionOfTwoNumsComRespDto != null) {
                        // TODO: 2024/6/8
                        receptionServiceReq_1.setQueueMinimum(calculateAdditionOfTwoNumsComRespDto.getCalcResult().intValue());//SimpleFieldAssign//sourceId:1832222_1_69717
                    }
                    if (calculateAdditionOfTwoNumsComRespDto_2 != null) {
                        // TODO: 2024/6/8
                        receptionServiceReq_1.setQueueMaximum(calculateAdditionOfTwoNumsComRespDto_2.getCalcResult().intValue());//SimpleFieldAssign//sourceId:1832223_1_69717
                    }

                    /*M2接收排序最小值与排序最大值[8782]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_1.getQueueMinimumOri(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最小值不能为空", false);
                    Assert.isNull(receptionServiceReq_1.getQueueMinimum(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最小值不能为空", false);
                    Assert.isNull(receptionServiceReq_1.getQueueMaximumOri(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最大值不能为空", false);
                    Assert.isNull(receptionServiceReq_1.getQueueMaximum(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最大值不能为空", false);
                    receptionServiceRes_2 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_1);


                    receptionServiceRes_3 = receptionServiceRes_2;
                }
                UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto = null;
                UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto = new UpdateRedisBusinessDataSetComReqDto();
                updateRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831809_1_69441
                updateRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1831811_1_69441
                updateRedisBusinessDataSetComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1831812_1_69441
                updateRedisBusinessDataSetComReqDto.setCustomField1("queueMinimum");//CUSTOM_CONVENTION//sourceId:1831814_1_69441
                updateRedisBusinessDataSetComReqDto.setCustomField2("queueMaximum");//CUSTOM_CONVENTION//sourceId:1831816_1_69441
                updateRedisBusinessDataSetComReqDto.setCustomField3("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1834502_1_69441
                updateRedisBusinessDataSetComReqDto.setCustomFieldValue3("TRUE");//CUSTOM_CONVENTION//sourceId:1834503_1_69441
                if (reqDto != null) {
                    updateRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1831810_1_69441
                    updateRedisBusinessDataSetComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831813_1_69441
                }
                if (receptionServiceRes_2 != null) {
                    updateRedisBusinessDataSetComReqDto.setCustomFieldValue1(receptionServiceRes_2.getQueueMinimum() != null ? String.valueOf(receptionServiceRes_2.getQueueMinimum()) : "");//SimpleFieldAssign//sourceId:1831815_1_69441
                    updateRedisBusinessDataSetComReqDto.setCustomFieldValue2(receptionServiceRes_2.getQueueMaximum() != null ? String.valueOf(receptionServiceRes_2.getQueueMaximum()) : "");//SimpleFieldAssign//sourceId:1831817_1_69441
                }

                /*D2修改评价模板MQ排队最小值与排队最大值[9407]   */
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-Redis数据对象目录不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-业务数据对象不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getIsDataList(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-是否是数据集对象不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomField1(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段1不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomFieldValue1(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段值1不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField1(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段1不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField2(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段2不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue2(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值2不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField3(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段3不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue3(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值3不能为空", false);
                updateRedisBusinessDataSetComRespDto = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


            } else if ((implementNumericalContrastMagnitudeComRespDto != null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() != null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("LATER"))) {
                //elseif(D2排队最小值与排队最大值比较.数值比较结果 等于 之后（大于）)  69438

//ModelCode: receptionService
                ImplementTenReceivingFieldRespDto receptionServiceRes_4 = null;
                ImplementTenReceivingFieldReqDto receptionServiceReq_2 = new ImplementTenReceivingFieldReqDto();
                receptionServiceReq_2.setComNumField(Long.valueOf(1));//CUSTOM_CONVENTION//sourceId:1832080_1_69443
                if (reqDto != null) {
                    receptionServiceReq_2.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1831819_1_69443
                    receptionServiceReq_2.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831818_1_69443
                }

                /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_2.getBusinessDataObject(), "D2遥控器MQ排队(修改单条redis)-M2接收入参字段-业务数据对象不能为空", false);
                Assert.isNull(receptionServiceReq_2.getEvaluationTemplateId(), "D2遥控器MQ排队(修改单条redis)-M2接收入参字段-冗余评价模板ID不能为空", false);
                Assert.isNull(receptionServiceReq_2.getComNumField(), "D2遥控器MQ排队(修改单条redis)-M2接收入参字段-通用数值字段（整数型）不能为空", false);
                receptionServiceRes_4 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_2);


                UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto_1 = null;
                UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto_1 = new UpdateRedisBusinessDataSetComReqDto();
                updateRedisBusinessDataSetComReqDto_1.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831809_1_69442
                updateRedisBusinessDataSetComReqDto_1.setIsDataList("TRUE");//sourceId:1831811_1_69442
                updateRedisBusinessDataSetComReqDto_1.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1831812_1_69442
                updateRedisBusinessDataSetComReqDto_1.setCustomField1("queueMinimum");//CUSTOM_CONVENTION//sourceId:1831814_1_69442
                updateRedisBusinessDataSetComReqDto_1.setCustomField2("queueMaximum");//CUSTOM_CONVENTION//sourceId:1831816_1_69442
                updateRedisBusinessDataSetComReqDto_1.setCustomField3("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1834502_1_69442
                updateRedisBusinessDataSetComReqDto_1.setCustomFieldValue3("TRUE");//CUSTOM_CONVENTION//sourceId:1834503_1_69442
                if (reqDto != null) {
                    updateRedisBusinessDataSetComReqDto_1.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1831810_1_69442
                    updateRedisBusinessDataSetComReqDto_1.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831813_1_69442
                }
                if (receptionServiceRes_4 != null) {
                    updateRedisBusinessDataSetComReqDto_1.setCustomFieldValue1(receptionServiceRes_4.getComNumField() != null ? String.valueOf(receptionServiceRes_4.getComNumField()) : "");//SimpleFieldAssign//sourceId:1831815_1_69442
                    updateRedisBusinessDataSetComReqDto_1.setCustomFieldValue2(receptionServiceRes_4.getComNumField() != null ? String.valueOf(receptionServiceRes_4.getComNumField()) : "");//SimpleFieldAssign//sourceId:1831817_1_69442
                }

                /*D2修改评价模板MQ排队最小值与排队最大值[9407]   */
                Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getRedisDataObjectCatalogue(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-Redis数据对象目录不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getBusinessDataObject(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-业务数据对象不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getIsDataList(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-是否是数据集对象不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getRefCustomField1(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段1不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getRefCustomFieldValue1(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段值1不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getCustomField1(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段1不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getCustomField2(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段2不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getCustomFieldValue2(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值2不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getCustomField3(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段3不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_1.getCustomFieldValue3(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值3不能为空", false);
                updateRedisBusinessDataSetComRespDto_1 = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto_1)/*vcase invoke isSameApp*/;


//ModelCode: receptionService
                ImplementTenReceivingFieldRespDto receptionServiceRes_6 = null;
                ImplementTenReceivingFieldReqDto receptionServiceReq_3 = new ImplementTenReceivingFieldReqDto();
                if (receptionServiceRes != null) {
                    receptionServiceReq_3.setQueueMinimumOri(receptionServiceRes.getQueueMinimum());//SimpleFieldAssign//sourceId:1832224_1_69445
                    receptionServiceReq_3.setQueueMaximumOri(receptionServiceRes.getQueueMaximum());//SimpleFieldAssign//sourceId:1832225_1_69445
                }
                if (receptionServiceRes_4 != null) {
                    receptionServiceReq_3.setQueueMinimum(receptionServiceRes_4.getComNumField());//SimpleFieldAssign//sourceId:1832222_1_69445
                    receptionServiceReq_3.setQueueMaximum(receptionServiceRes_4.getComNumField());//SimpleFieldAssign//sourceId:1832223_1_69445
                }

                /*M2接收排序最小值与排序最大值[8782]  用于特殊方法接收上游入参。 */
                Assert.isNull(receptionServiceReq_3.getQueueMinimumOri(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最小值不能为空", false);
                Assert.isNull(receptionServiceReq_3.getQueueMinimum(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最小值不能为空", false);
                Assert.isNull(receptionServiceReq_3.getQueueMaximumOri(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最大值不能为空", false);
                Assert.isNull(receptionServiceReq_3.getQueueMaximum(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最大值不能为空", false);
                receptionServiceRes_6 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_3);


                receptionServiceRes_3 = receptionServiceRes_6;
            } else if ((receptionServiceRes != null && receptionServiceRes.getQueueMinimum() > 0L && receptionServiceRes != null && receptionServiceRes.getQueueMaximum() > 0L) && (implementNumericalContrastMagnitudeComRespDto != null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() != null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("BEFORE") || implementNumericalContrastMagnitudeComRespDto != null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() != null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("PRESENT"))) {
                //elseif((M2接收原始排队最小值排队最大值.排队最小值 大于 0 and M2接收原始排队最小值排队最大值.排队最大值 大于 0) and (D2排队最小值与排队最大值比较.数值比较结果 等于 之前（小于） or D2排队最小值与排队最大值比较.数值比较结果 等于 当前（等于）))  69460

                CalculateAdditionOfTwoNumsComRespDto calculateAdditionOfTwoNumsComRespDto_4 = null;
                CalculateAdditionOfTwoNumsComReqDto calculateAdditionOfTwoNumsComReqDto_2 = new CalculateAdditionOfTwoNumsComReqDto();
                calculateAdditionOfTwoNumsComReqDto_2.setCalcPara2(Double.valueOf("1"));//CUSTOM_CONVENTION//sourceId:1834735_1_69466
                if (receptionServiceRes != null) {
                    calculateAdditionOfTwoNumsComReqDto_2.setCalcPara1(receptionServiceRes.getQueueMaximum() != null ? Double.valueOf(receptionServiceRes.getQueueMaximum()) : null);//SimpleFieldAssign//sourceId:1834734_1_69466
                }

                /*D2排队最大值+1[8137]   */
                Assert.isNull(calculateAdditionOfTwoNumsComReqDto_2.getCalcPara1(), "D2遥控器MQ排队(修改单条redis)-D2排队最大值+1-计算入参1不能为空", false);
                Assert.isNull(calculateAdditionOfTwoNumsComReqDto_2.getCalcPara2(), "D2遥控器MQ排队(修改单条redis)-D2排队最大值+1-计算入参2不能为空", false);
                calculateAdditionOfTwoNumsComRespDto_4 = interfaceModeService.calculateAdditionOfTwoNumsCom(calculateAdditionOfTwoNumsComReqDto_2)/*vcase invoke isSameApp*/;


//ModelCode: receptionService
                ImplementTenReceivingFieldRespDto receptionServiceRes_7 = null;
                if (calculateAdditionOfTwoNumsComRespDto_4 != null) {
                    ImplementTenReceivingFieldReqDto receptionServiceReq_4 = new ImplementTenReceivingFieldReqDto();
                    if (receptionServiceRes != null) {
                        receptionServiceReq_4.setQueueMinimumOri(receptionServiceRes.getQueueMinimum());//SimpleFieldAssign//sourceId:1832224_1_69718
                        receptionServiceReq_4.setQueueMinimum(receptionServiceRes.getQueueMinimum());//SimpleFieldAssign//sourceId:1832222_1_69718
                        receptionServiceReq_4.setQueueMaximumOri(receptionServiceRes.getQueueMaximum());//SimpleFieldAssign//sourceId:1832225_1_69718
                    }
                    if (calculateAdditionOfTwoNumsComRespDto_4 != null) {
                        // TODO: 2024/6/8
                        receptionServiceReq_4.setQueueMaximum(calculateAdditionOfTwoNumsComRespDto_4.getCalcResult().intValue());//SimpleFieldAssign//sourceId:1832223_1_69718
                    }

                    /*M2接收排序最小值与排序最大值[8782]  用于特殊方法接收上游入参。 */
                    Assert.isNull(receptionServiceReq_4.getQueueMinimumOri(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最小值不能为空", false);
                    Assert.isNull(receptionServiceReq_4.getQueueMinimum(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最小值不能为空", false);
                    Assert.isNull(receptionServiceReq_4.getQueueMaximumOri(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-原始排队最大值不能为空", false);
                    Assert.isNull(receptionServiceReq_4.getQueueMaximum(), "D2遥控器MQ排队(修改单条redis)-M2接收排序最小值与排序最大值-排队最大值不能为空", false);
                    receptionServiceRes_7 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_4);


                    receptionServiceRes_3 = receptionServiceRes_7;
                }
                UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto_2 = null;
                UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto_2 = new UpdateRedisBusinessDataSetComReqDto();
                updateRedisBusinessDataSetComReqDto_2.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831809_1_69462
                updateRedisBusinessDataSetComReqDto_2.setIsDataList("TRUE");//sourceId:1831811_1_69462
                updateRedisBusinessDataSetComReqDto_2.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1831812_1_69462
                updateRedisBusinessDataSetComReqDto_2.setCustomField1("queueMinimum");//CUSTOM_CONVENTION//sourceId:1831814_1_69462
                updateRedisBusinessDataSetComReqDto_2.setCustomField2("queueMaximum");//CUSTOM_CONVENTION//sourceId:1831816_1_69462
                updateRedisBusinessDataSetComReqDto_2.setCustomField3("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1834502_1_69462
                updateRedisBusinessDataSetComReqDto_2.setCustomFieldValue3("TRUE");//CUSTOM_CONVENTION//sourceId:1834503_1_69462
                if (reqDto != null) {
                    updateRedisBusinessDataSetComReqDto_2.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1831810_1_69462
                    updateRedisBusinessDataSetComReqDto_2.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831813_1_69462
                }
                if (receptionServiceRes_7 != null) {
                    updateRedisBusinessDataSetComReqDto_2.setCustomFieldValue2(receptionServiceRes_7.getQueueMaximum() != null ? String.valueOf(receptionServiceRes_7.getQueueMaximum()) : "");//SimpleFieldAssign//sourceId:1831817_1_69462
                }

                /*D2修改评价模板MQ排队最小值与排队最大值[9407]   */
                Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getRedisDataObjectCatalogue(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-Redis数据对象目录不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getBusinessDataObject(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-业务数据对象不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getIsDataList(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-是否是数据集对象不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getRefCustomField1(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段1不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getRefCustomFieldValue1(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-入参自定义字段值1不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getCustomField1(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段1不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getCustomField2(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段2不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getCustomFieldValue2(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值2不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getCustomField3(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段3不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto_2.getCustomFieldValue3(), "D2遥控器MQ排队(修改单条redis)-D2修改评价模板MQ排队最小值与排队最大值-自定义字段值3不能为空", false);
                updateRedisBusinessDataSetComRespDto_2 = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto_2)/*vcase invoke isSameApp*/;


            }
        } else {
            //else  69433

//异常结束 69434
            throw new BizException("C221000449", "对不起，MQ的遥控器redis未初始化~", false);
        }
        UpdateRemoteControllerMqQueueComRespDto retData = new UpdateRemoteControllerMqQueueComRespDto();
        if (receptionServiceRes_3 != null) {
            retData.setQueueMinimumOri(receptionServiceRes_3.getQueueMinimumOri() != null ? receptionServiceRes_3.getQueueMinimumOri().longValue() : null);//SimpleFieldAssign//sourceId:1832230_1
            retData.setQueueMinimum(receptionServiceRes_3.getQueueMinimum() != null ? receptionServiceRes_3.getQueueMinimum().longValue() : null);//SimpleFieldAssign//sourceId:1832231_1
            retData.setQueueMaximumOri(receptionServiceRes_3.getQueueMaximumOri() != null ? receptionServiceRes_3.getQueueMaximumOri().longValue() : null);//SimpleFieldAssign//sourceId:1832232_1
            retData.setQueueMaximum(receptionServiceRes_3.getQueueMaximum() != null ? receptionServiceRes_3.getQueueMaximum().longValue() : null);//SimpleFieldAssign//sourceId:1832233_1
        }


        return retData;
    }

    /**
     * D2规划目标计算MQ排队(新增单条redis)[9694]
     * gen by moon at 6/8/2024, 8:04:35 PM
     */
    @Trace(operationName = "D2规划目标计算MQ排队(新增单条redis)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddPlanTargetCalcMqQueueRedisComRespDto addPlanTargetCalcMqQueueRedisCom(AddPlanTargetCalcMqQueueRedisComReqDto reqDto) {


        //步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1832214_1
            receptionServiceReq.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1855399_1
            receptionServiceReq.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1855400_1
        }

        /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D2规划目标计算MQ排队(新增单条redis)-M2接收入参字段-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleStartTime(), "D2规划目标计算MQ排队(新增单条redis)-M2接收入参字段-更新周期开始时间不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleEndTime(), "D2规划目标计算MQ排队(新增单条redis)-M2接收入参字段-更新周期结束时间不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//步骤1: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
        ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto = new ImplementTimeFormatConversionComReqDto();
        if (reqDto != null) {
            implementTimeFormatConversionComReqDto.setComTxtField(reqDto.getUpdateCycleStartTime() != null ? String.valueOf(reqDto.getUpdateCycleStartTime()) : "");//SimpleFieldAssign//sourceId:1855405_1
        }

        /*D2更新周期开始时间[9757]   */
        Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(), "D2规划目标计算MQ排队(新增单条redis)-D2更新周期开始时间-通用文本字段不能为空", false);
        implementTimeFormatConversionComRespDto = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto_2 = null;
        ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto_1 = new ImplementTimeFormatConversionComReqDto();
        if (reqDto != null) {
            implementTimeFormatConversionComReqDto_1.setComTxtField(reqDto.getUpdateCycleEndTime() != null ? String.valueOf(reqDto.getUpdateCycleEndTime()) : "");//SimpleFieldAssign//sourceId:1855407_1
        }

        /*D2更新周期结束时间[9757]   */
        Assert.isNull(implementTimeFormatConversionComReqDto_1.getComTxtField(), "D2规划目标计算MQ排队(新增单条redis)-D2更新周期结束时间-通用文本字段不能为空", false);
        implementTimeFormatConversionComRespDto_2 = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto_1)/*vcase invoke isSameApp*/;


//步骤3: D2-新增redis业务数据对象（业务原子） - addRedisBusinessDataSetCom
        AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
        if (implementTimeFormatConversionComRespDto != null) {
            AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto = new AddRedisBusinessDataSetComReqDto();
            addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1831938_1
            addRedisBusinessDataSetComReqDto.setBusinessDataObject("PLAN_TARGET_CALC_MQ_QUEUE");//sourceId:1831937_1
            addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1831939_1
            addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1831940_1
            addRedisBusinessDataSetComReqDto.setCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:1831941_1
            addRedisBusinessDataSetComReqDto.setCustomField2("targetAttributionCycleId");//CUSTOM_CONVENTION//sourceId:1831943_1
            addRedisBusinessDataSetComReqDto.setCustomField3("isLastCycle");//CUSTOM_CONVENTION//sourceId:1832386_1
            addRedisBusinessDataSetComReqDto.setCustomField4("spaceId");//CUSTOM_CONVENTION//sourceId:1849443_1
            addRedisBusinessDataSetComReqDto.setCustomField5("appId");//CUSTOM_CONVENTION//sourceId:1849445_1
            addRedisBusinessDataSetComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1849447_1
            addRedisBusinessDataSetComReqDto.setCustomField7("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:1852045_1
            addRedisBusinessDataSetComReqDto.setCustomField8("updateCycleId");//CUSTOM_CONVENTION//sourceId:1852047_1
            addRedisBusinessDataSetComReqDto.setCustomField9("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:1852049_1
            addRedisBusinessDataSetComReqDto.setCustomField10("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:1852051_1
            addRedisBusinessDataSetComReqDto.setCustomField11("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:1852053_1
            if (reqDto != null) {
                addRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1831947_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getCustomFieldValue1());//SimpleFieldAssign//sourceId:1831942_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue2(reqDto.getCustomFieldValue2());//SimpleFieldAssign//sourceId:1831944_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue3(reqDto.getCustomFieldValue3());//SimpleFieldAssign//sourceId:1832387_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue4(reqDto.getCustomFieldValue4());//SimpleFieldAssign//sourceId:1849444_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue5(reqDto.getCustomFieldValue5());//SimpleFieldAssign//sourceId:1849446_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue6(reqDto.getCustomFieldValue6());//SimpleFieldAssign//sourceId:1849448_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue7(reqDto.getCustomFieldValue7());//SimpleFieldAssign//sourceId:1852046_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue8(reqDto.getCustomFieldValue8());//SimpleFieldAssign//sourceId:1852048_1

                addRedisBusinessDataSetComReqDto.setCustomFieldValue11(reqDto.getCustomFieldValue11());//SimpleFieldAssign//sourceId:1852054_1
            }
            if (implementTimeFormatConversionComRespDto != null) {
                addRedisBusinessDataSetComReqDto.setCustomFieldValue9(implementTimeFormatConversionComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1852050_1
            }
            if (implementTimeFormatConversionComRespDto_2 != null) {
                addRedisBusinessDataSetComReqDto.setCustomFieldValue10(implementTimeFormatConversionComRespDto_2.getComTxtField());//SimpleFieldAssign//sourceId:1852052_1
            }

            /*D2-新增redis业务数据对象（业务原子）[8399]   */
            Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getDataObjectBatchCode(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-数据对象批次标识不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-是否删除redis历史数据不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段1不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值1不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段2不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值2不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段3不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值3不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段4不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值4不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段5不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值5不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段6不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值6不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段7不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段8不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值8不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段9不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值9不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField10(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段10不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue10(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值10不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField11(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段11不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue11(), "D2规划目标计算MQ排队(新增单条redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值11不能为空", false);
            addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


        }

        AddPlanTargetCalcMqQueueRedisComRespDto retData = new AddPlanTargetCalcMqQueueRedisComRespDto();


        return retData;
    }

    /**
     * D2执行规划目标计算MQ排队(公共)[9696]
     * gen by moon at 6/8/2024, 3:19:51 AM
     */
    @Trace(operationName = "D2执行规划目标计算MQ排队(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementPlanTargetCalcMqQueueComRespDto implementPlanTargetCalcMqQueueCom(ImplementPlanTargetCalcMqQueueComReqDto reqDto) {


        //virtualUsage D2执行并发行为主题锁(悬停等待)-上锁  69456
        ImplementConcurrencyBehaviorThemeLockWaitComRespDto implementConcurrencyBehaviorThemeLockWaitComRespDto = null;
        ImplementConcurrencyBehaviorThemeLockWaitComReqDto implementConcurrencyBehaviorThemeLockWaitComReqDto = new ImplementConcurrencyBehaviorThemeLockWaitComReqDto();
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1834296_1_69456
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setBusinessDataObject("MQ_HOVER_QUEUE_LOCK");//sourceId:1834297_1_69456
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1834299_1_69456
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setWaitingTime("10");//CUSTOM_CONVENTION//sourceId:1834300_1_69456
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setWaitTimeUnitType("MINUTES");//sourceId:1834301_1_69456
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1834302_1_69456
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setTimeUnitType("MINUTES");//sourceId:1834303_1_69456
        if (reqDto != null) {
            implementConcurrencyBehaviorThemeLockWaitComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834298_1_69456
        }

        /*D2执行并发行为主题锁(悬停等待)-上锁[9699]   */
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getRedisDataObjectCatalogue(), "D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-Redis数据对象目录不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getBusinessDataObject(), "D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-业务数据对象不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getDataObjectBatchCode(), "D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-数据对象批次标识不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getPreventConcurrentLockingUnlocking(), "D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getDuration(), "D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-锁定时长不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getTimeUnitType(), "D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-上锁-时间单位类型不能为空", false);
        implementConcurrencyBehaviorThemeLockWaitComRespDto = interfaceModeService.implementConcurrencyBehaviorThemeLockWaitCom(implementConcurrencyBehaviorThemeLockWaitComReqDto)/*vcase invoke isSameApp*/;


        if ((implementConcurrencyBehaviorThemeLockWaitComRespDto != null && implementConcurrencyBehaviorThemeLockWaitComRespDto.getPreventConcurrentLockingSituations() != null && implementConcurrencyBehaviorThemeLockWaitComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行并发行为主题锁(悬停等待)-上锁.防并发上锁情况 等于 空上锁成功)  69545

            UpdateRemoteControllerMqQueueComRespDto updateRemoteControllerMqQueueComRespDto = null;
            UpdateRemoteControllerMqQueueComReqDto updateRemoteControllerMqQueueComReqDto = new UpdateRemoteControllerMqQueueComReqDto();
            updateRemoteControllerMqQueueComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1832234_1_69546
            if (reqDto != null) {
                updateRemoteControllerMqQueueComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1832235_1_69546
            }

            /*D2遥控器MQ排队(修改单条redis)[9693]   */
            Assert.isNull(updateRemoteControllerMqQueueComReqDto.getBusinessDataObject(), "D2执行规划目标计算MQ排队(公共)-D2遥控器MQ排队(修改单条redis)-业务数据对象不能为空", false);
            Assert.isNull(updateRemoteControllerMqQueueComReqDto.getEvaluationTemplateId(), "D2执行规划目标计算MQ排队(公共)-D2遥控器MQ排队(修改单条redis)-冗余评价模板ID不能为空", false);
            updateRemoteControllerMqQueueComRespDto = updateRemoteControllerMqQueueCom(updateRemoteControllerMqQueueComReqDto)/*vcase invoke 同服务,同domain*/;


            if ((updateRemoteControllerMqQueueComRespDto != null && updateRemoteControllerMqQueueComRespDto.getQueueMinimum() != null && updateRemoteControllerMqQueueComRespDto != null && updateRemoteControllerMqQueueComRespDto.getQueueMaximum() != null)) {
                //if((D2遥控器MQ排队(修改单条redis).排队最小值 值不等于空  and D2遥控器MQ排队(修改单条redis).排队最大值 值不等于空 ))  69547

                AddPlanTargetCalcMqQueueRedisComRespDto addPlanTargetCalcMqQueueRedisComRespDto = null;
                if (updateRemoteControllerMqQueueComRespDto != null) {
                    AddPlanTargetCalcMqQueueRedisComReqDto addPlanTargetCalcMqQueueRedisComReqDto = new AddPlanTargetCalcMqQueueRedisComReqDto();
                    addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue4(CommonFunctionHelper.getBaseInfoFromLocal().getSpecSpaceId());//CURRENT_SPACEID//sourceId:1849452_1_69548
                    addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue5(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1849453_1_69548
                    addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue6(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1852137_1_69548
                    if (updateRemoteControllerMqQueueComRespDto != null) {
                        addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue1(updateRemoteControllerMqQueueComRespDto.getQueueMaximum() != null ? String.valueOf(updateRemoteControllerMqQueueComRespDto.getQueueMaximum()) : "");//SimpleFieldAssign//sourceId:1832389_1_69548
                    }
                    if (reqDto != null) {
                        addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue2(reqDto.getTargetAttributionCycleId());//SimpleFieldAssign//sourceId:1832390_1_69548
                        addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue7(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1852062_1_69548
                        addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue8(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1852063_1_69548
                        addPlanTargetCalcMqQueueRedisComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1855403_1_69548
                        addPlanTargetCalcMqQueueRedisComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1855404_1_69548
                        addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue11(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1852066_1_69548
                        addPlanTargetCalcMqQueueRedisComReqDto.setCustomFieldValue3(reqDto.getIsLastCycle());//SimpleFieldAssign//sourceId:1832391_1_69548
                        addPlanTargetCalcMqQueueRedisComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1832242_1_69548
                    }

                    /*D2规划目标计算MQ排队(新增单条redis)[9694]   */
                    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue1(), "D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-排队值不能为空", false);
                    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue2(), "D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-目标归属周期ID不能为空", false);
                    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue8(), "D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-更新周期ID不能为空", false);
                    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getUpdateCycleStartTime(), "D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-更新周期开始时间不能为空", false);
                    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getUpdateCycleEndTime(), "D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-更新周期结束时间不能为空", false);
                    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue11(), "D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-更新周期类型标识不能为空", false);
                    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue3(), "D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-更新周期是否末级周期不能为空", false);
                    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getEvaluationTemplateId(), "D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-冗余评价模板ID不能为空", false);
                    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue4(), "D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-创建于空间ID不能为空", false);
                    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue5(), "D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-创建于联盟应用ID不能为空", false);
                    Assert.isNull(addPlanTargetCalcMqQueueRedisComReqDto.getCustomFieldValue6(), "D2执行规划目标计算MQ排队(公共)-D2规划目标计算MQ排队(新增单条redis)-操作人就职记录ID不能为空", false);
                    addPlanTargetCalcMqQueueRedisComRespDto = addPlanTargetCalcMqQueueRedisCom(addPlanTargetCalcMqQueueRedisComReqDto)/*vcase invoke 同服务,同domain*/;


                }
            }
            ImplementConcurrencyBehaviorThemeLockWaitComRespDto implementConcurrencyBehaviorThemeLockWaitComRespDto_2 = null;
            ImplementConcurrencyBehaviorThemeLockWaitComReqDto implementConcurrencyBehaviorThemeLockWaitComReqDto_1 = new ImplementConcurrencyBehaviorThemeLockWaitComReqDto();
            implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1834304_1_69549
            implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setBusinessDataObject("MQ_HOVER_QUEUE_LOCK");//sourceId:1834305_1_69549
            implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1834307_1_69549
            if (reqDto != null) {
                implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834306_1_69549
            }

            /*D2执行并发行为主题锁(悬停等待)-解锁[9699]   */
            Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getRedisDataObjectCatalogue(), "D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-解锁-Redis数据对象目录不能为空", false);
            Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getBusinessDataObject(), "D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-解锁-业务数据对象不能为空", false);
            Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getDataObjectBatchCode(), "D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-解锁-数据对象批次标识不能为空", false);
            Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getPreventConcurrentLockingUnlocking(), "D2执行规划目标计算MQ排队(公共)-D2执行并发行为主题锁(悬停等待)-解锁-防并发上锁or解锁不能为空", false);
            implementConcurrencyBehaviorThemeLockWaitComRespDto_2 = interfaceModeService.implementConcurrencyBehaviorThemeLockWaitCom(implementConcurrencyBehaviorThemeLockWaitComReqDto_1)/*vcase invoke isSameApp*/;


        }
        ImplementPlanTargetCalcMqQueueComRespDto retData = new ImplementPlanTargetCalcMqQueueComRespDto();


        return retData;
    }

    /**
     * D2准备统计资金来源及账户配置参数(公共)[9701]
     * gen by moon at 6/1/2024, 12:55:55 AM
     */
    @Trace(operationName = "D2准备统计资金来源及账户配置参数(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public PreparationStatisticalFundSourcesAccountConfParametersComRespDto preparationStatisticalFundSourcesAccountConfParametersCom(PreparationStatisticalFundSourcesAccountConfParametersComReqDto reqDto) {


        ImplementTenReceivingFieldRespDto receptionServiceRes_2 = null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834098_1
            receptionServiceReq.setEvaluationSubjectId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834182_1
            receptionServiceReq.setSpaceId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1834258_1
        }

        /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D2准备统计资金来源及账户配置参数(公共)-M2接收入参字段-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getEvaluationSubjectId(), "D2准备统计资金来源及账户配置参数(公共)-M2接收入参字段-冗余评价主题ID不能为空", false);
        Assert.isNull(receptionServiceReq.getSpaceId(), "D2准备统计资金来源及账户配置参数(公共)-M2接收入参字段-创建于空间ID不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("TENANT_SPACE");//sourceId:1834247_1
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("IS_OPEN_FINANCE");//CUSTOM_CONVENTION//sourceId:1834248_1
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1834249_1
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1834246_1
        }

        /*D2查空间开启财务管理模式配置参数（公共）[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D2准备统计资金来源及账户配置参数(公共)-D2查空间开启财务管理模式配置参数（公共）-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(), "D2准备统计资金来源及账户配置参数(公共)-D2查空间开启财务管理模式配置参数（公共）-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D2准备统计资金来源及账户配置参数(公共)-D2查空间开启财务管理模式配置参数（公共）-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D2准备统计资金来源及账户配置参数(公共)-D2查空间开启财务管理模式配置参数（公共）-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1 = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjType("EVA_TEMP");//sourceId:1834251_1
        queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("CYCLE_MODE");//CUSTOM_CONVENTION//sourceId:1834252_1
        queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1834253_1
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834250_1
        }

        /*D2查评价模板周期模式配置参数答案（公共）[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价模板周期模式配置参数答案（公共）-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjType(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价模板周期模式配置参数答案（公共）-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价模板周期模式配置参数答案（公共）-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价模板周期模式配置参数答案（公共）-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto_2 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1)/*vcase invoke isSameApp*/;


//步骤3: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_4 = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_2 = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto_2.setResultAspObjType("EVA_THEME");//sourceId:1834288_1
        queryConfItemMatchAnswerDetailComReqDto_2.setConfItemCode("IS_OPEN_BUDGET");//CUSTOM_CONVENTION//sourceId:1834289_1
        queryConfItemMatchAnswerDetailComReqDto_2.setIsPlatData("FALSE");//sourceId:1834290_1
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto_2.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834287_1
        }

        /*D2查评价主题是否开启预算配置参数（公共）[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getResultAspObjId(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题是否开启预算配置参数（公共）-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getResultAspObjType(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题是否开启预算配置参数（公共）-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getConfItemCode(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题是否开启预算配置参数（公共）-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_2.getIsPlatData(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题是否开启预算配置参数（公共）-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto_4 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_2)/*vcase invoke isSameApp*/;


//步骤4: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_6 = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_3 = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto_3.setResultAspObjType("EVA_THEME");//sourceId:1834293_1
        queryConfItemMatchAnswerDetailComReqDto_3.setConfItemCode("BUDGET_HIERARCHY");//CUSTOM_CONVENTION//sourceId:1834294_1
        queryConfItemMatchAnswerDetailComReqDto_3.setIsPlatData("FALSE");//sourceId:1834295_1
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto_3.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834292_1
        }

        /*D2-3查评价主题配置预算层级参数（公共）[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getResultAspObjId(), "D2准备统计资金来源及账户配置参数(公共)-D2-3查评价主题配置预算层级参数（公共）-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getResultAspObjType(), "D2准备统计资金来源及账户配置参数(公共)-D2-3查评价主题配置预算层级参数（公共）-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getConfItemCode(), "D2准备统计资金来源及账户配置参数(公共)-D2-3查评价主题配置预算层级参数（公共）-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_3.getIsPlatData(), "D2准备统计资金来源及账户配置参数(公共)-D2-3查评价主题配置预算层级参数（公共）-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto_6 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_3)/*vcase invoke isSameApp*/;


//步骤5: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_8 = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_4 = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto_4.setResultAspObjType("EVA_THEME");//sourceId:1834314_1
        queryConfItemMatchAnswerDetailComReqDto_4.setConfItemCode("BUDGET_REPORT_HIERARCHY");//CUSTOM_CONVENTION//sourceId:1834315_1
        queryConfItemMatchAnswerDetailComReqDto_4.setIsPlatData("FALSE");//sourceId:1834316_1
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto_4.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834313_1
        }

        /*D2查评价主题配置费用汇报层级配置参数[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getResultAspObjId(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置费用汇报层级配置参数-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getResultAspObjType(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置费用汇报层级配置参数-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getConfItemCode(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置费用汇报层级配置参数-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_4.getIsPlatData(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置费用汇报层级配置参数-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto_8 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_4)/*vcase invoke isSameApp*/;


//步骤6: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_10 = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_5 = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto_5.setResultAspObjType("EVA_THEME");//sourceId:1834320_1
        queryConfItemMatchAnswerDetailComReqDto_5.setConfItemCode("IS_OPEN_FUNDS_ARRIVAL");//CUSTOM_CONVENTION//sourceId:1834321_1
        queryConfItemMatchAnswerDetailComReqDto_5.setIsPlatData("FALSE");//sourceId:1834322_1
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto_5.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834319_1
        }

        /*D2查评价主题配置是否开启资金到账配置参数[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getResultAspObjId(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置是否开启资金到账配置参数-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getResultAspObjType(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置是否开启资金到账配置参数-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getConfItemCode(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置是否开启资金到账配置参数-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_5.getIsPlatData(), "D2准备统计资金来源及账户配置参数(公共)-D2查评价主题配置是否开启资金到账配置参数-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto_10 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_5)/*vcase invoke isSameApp*/;


//步骤7: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_12 = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_6 = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto_6.setResultAspObjType("EVA_THEME");//sourceId:1834325_1
        queryConfItemMatchAnswerDetailComReqDto_6.setConfItemCode("CASH_ACCOUNT_UNIT");//CUSTOM_CONVENTION//sourceId:1834326_1
        queryConfItemMatchAnswerDetailComReqDto_6.setIsPlatData("FALSE");//sourceId:1834327_1
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto_6.setResultAspObjId(reqDto.getEvaluationSubjectId());//SimpleFieldAssign//sourceId:1834324_1
        }

        /*D2查询评价主题配置资金单位参数[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getResultAspObjId(), "D2准备统计资金来源及账户配置参数(公共)-D2查询评价主题配置资金单位参数-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getResultAspObjType(), "D2准备统计资金来源及账户配置参数(公共)-D2查询评价主题配置资金单位参数-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getConfItemCode(), "D2准备统计资金来源及账户配置参数(公共)-D2查询评价主题配置资金单位参数-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_6.getIsPlatData(), "D2准备统计资金来源及账户配置参数(公共)-D2查询评价主题配置资金单位参数-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto_12 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_6)/*vcase invoke isSameApp*/;


//步骤8: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_1 = null;
        if (queryConfItemMatchAnswerDetailComRespDto_2 != null) {
            ImplementTenReceivingFieldReqDto receptionServiceReq_1 = new ImplementTenReceivingFieldReqDto();
            if (queryConfItemMatchAnswerDetailComRespDto_2 != null) {
                receptionServiceReq_1.setCycleMode(queryConfItemMatchAnswerDetailComRespDto_2.getEndValue());//SimpleFieldAssign//sourceId:1834481_1
            }
            if (queryConfItemMatchAnswerDetailComRespDto != null) {
                receptionServiceReq_1.setIsOpenFinance(queryConfItemMatchAnswerDetailComRespDto.getEndValue());//SimpleFieldAssign//sourceId:1834477_1
            }
            if (queryConfItemMatchAnswerDetailComRespDto_4 != null) {
                receptionServiceReq_1.setIsOpenBudget(queryConfItemMatchAnswerDetailComRespDto_4.getEndValue());//SimpleFieldAssign//sourceId:1834483_1
            }
            if (queryConfItemMatchAnswerDetailComRespDto_6 != null) {
                receptionServiceReq_1.setBudgetLevel(queryConfItemMatchAnswerDetailComRespDto_6.getEndValue());//SimpleFieldAssign//sourceId:1834476_1
            }
            if (queryConfItemMatchAnswerDetailComRespDto_8 != null) {
                receptionServiceReq_1.setCostReportLevel(queryConfItemMatchAnswerDetailComRespDto_8.getEndValue());//SimpleFieldAssign//sourceId:1834478_1
            }
            if (queryConfItemMatchAnswerDetailComRespDto_10 != null) {
                receptionServiceReq_1.setIsOpenFundsArrival(queryConfItemMatchAnswerDetailComRespDto_10.getEndValue());//SimpleFieldAssign//sourceId:1834479_1
            }
            if (queryConfItemMatchAnswerDetailComRespDto_12 != null) {
                receptionServiceReq_1.setFundUnit(queryConfItemMatchAnswerDetailComRespDto_12.getConfOptionName());//SimpleFieldAssign//sourceId:1834480_1
            }

            /*M2接收预算配置相关参数[8782]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getCycleMode(), "D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-周期模式不能为空", false);
            Assert.isNull(receptionServiceReq_1.getIsOpenFinance(), "D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-开启财务管理模式不能为空", false);
            Assert.isNull(receptionServiceReq_1.getIsOpenBudget(), "D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-是否启用预算不能为空", false);
            Assert.isNull(receptionServiceReq_1.getBudgetLevel(), "D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-预算层级不能为空", false);
            Assert.isNull(receptionServiceReq_1.getCostReportLevel(), "D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-费用汇报层级不能为空", false);
            Assert.isNull(receptionServiceReq_1.getIsOpenFundsArrival(), "D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-是否开启资金到账不能为空", false);
            Assert.isNull(receptionServiceReq_1.getFundUnit(), "D2准备统计资金来源及账户配置参数(公共)-M2接收预算配置相关参数-资金单位不能为空", false);
            receptionServiceRes_1 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_1);


            receptionServiceRes_2 = receptionServiceRes_1;
        }

        PreparationStatisticalFundSourcesAccountConfParametersComRespDto retData = new PreparationStatisticalFundSourcesAccountConfParametersComRespDto();
        if (receptionServiceRes_2 != null) {
            retData.setIsOpenBudget(receptionServiceRes_2.getIsOpenBudget());//SimpleFieldAssign//sourceId:1834495_1
            retData.setBudgetLevel(receptionServiceRes_2.getBudgetLevel());//SimpleFieldAssign//sourceId:1834496_1
            retData.setCostReportLevel(receptionServiceRes_2.getCostReportLevel());//SimpleFieldAssign//sourceId:1834497_1
            retData.setIsOpenFundsArrival(receptionServiceRes_2.getIsOpenFundsArrival());//SimpleFieldAssign//sourceId:1834498_1
            retData.setFundUnit(receptionServiceRes_2.getFundUnit());//SimpleFieldAssign//sourceId:1834499_1
            retData.setIsOpenFinance(receptionServiceRes_2.getIsOpenFinance());//SimpleFieldAssign//sourceId:1834494_1
            retData.setCycleMode(receptionServiceRes_2.getCycleMode());//SimpleFieldAssign//sourceId:1834493_1
        }


        return retData;
    }

    /**
     * D2新增OKR目标计算MQ遥控器(公共)[9697]
     * gen by moon at 6/2/2024, 1:02:14 AM
     */
    @Trace(operationName = "D2新增OKR目标计算MQ遥控器(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddOkrTargetCalcMqRemoteControllerComRespDto addOkrTargetCalcMqRemoteControllerCom(AddOkrTargetCalcMqRemoteControllerComReqDto reqDto) {


        //virtualUsage M2接收入参字段  69469
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        receptionServiceReq.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1835318_1_69469
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1835316_1_69469
        }

        /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D2新增OKR目标计算MQ遥控器(公共)-M2接收入参字段-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getOperateTime(), "D2新增OKR目标计算MQ遥控器(公共)-M2接收入参字段-操作时间不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//virtualUsage D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）  69492
        QuerySingleRemoteControllerRedisDetailComRespDto querySingleRemoteControllerRedisDetailComRespDto = null;
        QuerySingleRemoteControllerRedisDetailComReqDto querySingleRemoteControllerRedisDetailComReqDto = new QuerySingleRemoteControllerRedisDetailComReqDto();
        querySingleRemoteControllerRedisDetailComReqDto.setBusinessDataObject("OKR_TARGET_CALC_MQ_REMOTE_CONTROLLER");//sourceId:1839430_1_69492
        querySingleRemoteControllerRedisDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839431_1_69492
        querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839432_1_69492
        if (reqDto != null) {
            querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839433_1_69492
        }

        /*D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）[9708]   */
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getBusinessDataObject(), "D2新增OKR目标计算MQ遥控器(公共)-D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）-业务数据对象不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRedisDataObjectCatalogue(), "D2新增OKR目标计算MQ遥控器(公共)-D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）-Redis数据对象目录不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField1(), "D2新增OKR目标计算MQ遥控器(公共)-D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）-入参自定义字段1不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue1(), "D2新增OKR目标计算MQ遥控器(公共)-D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）-入参自定义字段值1不能为空", false);
        querySingleRemoteControllerRedisDetailComRespDto = querySingleRemoteControllerRedisDetailCom(querySingleRemoteControllerRedisDetailComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((querySingleRemoteControllerRedisDetailComRespDto != null && querySingleRemoteControllerRedisDetailComRespDto.getEvaluationTemplateId() == null)) {
            //if(D2查询OKR目标计算MQ遥控器Redis（用于判断是否已存在）.评价模板ID 值等于空 )  69471

            PreparationOkrTargetCalcConfParametersComRespDto preparationOkrTargetCalcConfParametersComRespDto = null;
            PreparationOkrTargetCalcConfParametersComReqDto preparationOkrTargetCalcConfParametersComReqDto = new PreparationOkrTargetCalcConfParametersComReqDto();
            if (reqDto != null) {
                preparationOkrTargetCalcConfParametersComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1835076_1_69472
            }

            /*D2准备OKR目标计算配置参数(公共)[9703]   */
            Assert.isNull(preparationOkrTargetCalcConfParametersComReqDto.getEvaluationTemplateId(), "D2新增OKR目标计算MQ遥控器(公共)-D2准备OKR目标计算配置参数(公共)-冗余评价模板ID不能为空", false);
            preparationOkrTargetCalcConfParametersComRespDto = preparationOkrTargetCalcConfParametersCom(preparationOkrTargetCalcConfParametersComReqDto)/*vcase invoke 同服务,同domain*/;


            AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
            if (preparationOkrTargetCalcConfParametersComRespDto != null) {
                AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto = new AddRedisBusinessDataSetComReqDto();
                addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1835480_1_69473
                addRedisBusinessDataSetComReqDto.setBusinessDataObject("OKR_TARGET_CALC_MQ_REMOTE_CONTROLLER");//sourceId:1835479_1_69473
                addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1835482_1_69473
                addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1835481_1_69473
                addRedisBusinessDataSetComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1835483_1_69473
                addRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1835485_1_69473
                addRedisBusinessDataSetComReqDto.setCustomFieldValue2("0");//CUSTOM_CONVENTION//sourceId:1835486_1_69473
                addRedisBusinessDataSetComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1835487_1_69473
                addRedisBusinessDataSetComReqDto.setCustomFieldValue3("0");//CUSTOM_CONVENTION//sourceId:1835488_1_69473
                addRedisBusinessDataSetComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1835489_1_69473
                addRedisBusinessDataSetComReqDto.setCustomFieldValue4("FALSE");//CUSTOM_CONVENTION//sourceId:1835490_1_69473
                addRedisBusinessDataSetComReqDto.setCustomField5("MQ_REMOTE_CONTROLLER_NAME");//CUSTOM_CONVENTION//sourceId:1835491_1_69473
                addRedisBusinessDataSetComReqDto.setCustomFieldValue5("OKR_TARGET_CALC");//CUSTOM_CONVENTION//sourceId:1835492_1_69473
                addRedisBusinessDataSetComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1835493_1_69473
                addRedisBusinessDataSetComReqDto.setCustomFieldValue6(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1835494_1_69473
                addRedisBusinessDataSetComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1835495_1_69473
                addRedisBusinessDataSetComReqDto.setCustomField8("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:1835497_1_69473
                if (reqDto != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1835484_1_69473
                }
                if (receptionServiceRes != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue7(DateUtil.format(receptionServiceRes.getOperateTime(), "yyyy-MM-dd HH:mm:ss"));//SimpleFieldAssign//sourceId:1835496_1_69473
                }
                if (preparationOkrTargetCalcConfParametersComRespDto != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue8(preparationOkrTargetCalcConfParametersComRespDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:1835498_1_69473
                }

                /*D2增OKR目标计算MQ遥控器Redis[8399]   */
                Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-Redis数据对象目录不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-业务数据对象不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-是否是数据集对象不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-是否删除redis历史数据不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段1不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值1不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段2不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值2不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段3不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值3不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段4不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值4不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段5不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值5不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段6不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值6不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段7不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值7不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段8不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(), "D2新增OKR目标计算MQ遥控器(公共)-D2增OKR目标计算MQ遥控器Redis-自定义字段值8不能为空", false);
                addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


            }
        }
        AddOkrTargetCalcMqRemoteControllerComRespDto retData = new AddOkrTargetCalcMqRemoteControllerComRespDto();


        return retData;
    }

    /**
     * D2新增绩效目标计算MQ遥控器(公共)[9698]
     * gen by moon at 6/2/2024, 1:02:16 AM
     */
    @Trace(operationName = "D2新增绩效目标计算MQ遥控器(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddKpiTargetCalcMqRemoteControllerComRespDto addKpiTargetCalcMqRemoteControllerCom(AddKpiTargetCalcMqRemoteControllerComReqDto reqDto) {


        //virtualUsage M2接收入参字段  69481
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        receptionServiceReq.setOperateTime(CommonFunctionHelper.getCurrentTime());//SYSTEM_CURRENT_TIME//sourceId:1836480_1_69481
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1836479_1_69481
        }

        /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D2新增绩效目标计算MQ遥控器(公共)-M2接收入参字段-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getOperateTime(), "D2新增绩效目标计算MQ遥控器(公共)-M2接收入参字段-操作时间不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//virtualUsage D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）  69491
        QuerySingleRemoteControllerRedisDetailComRespDto querySingleRemoteControllerRedisDetailComRespDto = null;
        QuerySingleRemoteControllerRedisDetailComReqDto querySingleRemoteControllerRedisDetailComReqDto = new QuerySingleRemoteControllerRedisDetailComReqDto();
        querySingleRemoteControllerRedisDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839426_1_69491
        querySingleRemoteControllerRedisDetailComReqDto.setBusinessDataObject("KPI_TARGET_CALC_MQ_REMOTE_CONTROLLER");//sourceId:1839425_1_69491
        querySingleRemoteControllerRedisDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839427_1_69491
        if (reqDto != null) {
            querySingleRemoteControllerRedisDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839428_1_69491
        }

        /*D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）[9708]   */
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRedisDataObjectCatalogue(), "D2新增绩效目标计算MQ遥控器(公共)-D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）-Redis数据对象目录不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getBusinessDataObject(), "D2新增绩效目标计算MQ遥控器(公共)-D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）-业务数据对象不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomField1(), "D2新增绩效目标计算MQ遥控器(公共)-D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）-入参自定义字段1不能为空", false);
        Assert.isNull(querySingleRemoteControllerRedisDetailComReqDto.getRefCustomFieldValue1(), "D2新增绩效目标计算MQ遥控器(公共)-D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）-入参自定义字段值1不能为空", false);
        querySingleRemoteControllerRedisDetailComRespDto = querySingleRemoteControllerRedisDetailCom(querySingleRemoteControllerRedisDetailComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((querySingleRemoteControllerRedisDetailComRespDto != null && querySingleRemoteControllerRedisDetailComRespDto.getEvaluationTemplateId() == null)) {
            //if(D2查询绩效目标计算MQ遥控器Redis（用于判断是否已存在）.评价模板ID 值等于空 )  69483

            PreparationKpiTargetCalcConfParametersComRespDto preparationKpiTargetCalcConfParametersComRespDto = null;
            PreparationKpiTargetCalcConfParametersComReqDto preparationKpiTargetCalcConfParametersComReqDto = new PreparationKpiTargetCalcConfParametersComReqDto();
            if (reqDto != null) {
                preparationKpiTargetCalcConfParametersComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1837501_1_69484
            }

            /*D2准备绩效目标计算配置参数(公共)[9705]   */
            Assert.isNull(preparationKpiTargetCalcConfParametersComReqDto.getEvaluationTemplateId(), "D2新增绩效目标计算MQ遥控器(公共)-D2准备绩效目标计算配置参数(公共)-冗余评价模板ID不能为空", false);
            preparationKpiTargetCalcConfParametersComRespDto = preparationKpiTargetCalcConfParametersCom(preparationKpiTargetCalcConfParametersComReqDto)/*vcase invoke 同服务,同domain*/;


            AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
            if (preparationKpiTargetCalcConfParametersComRespDto != null) {
                AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto = new AddRedisBusinessDataSetComReqDto();
                addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1837766_1_69485
                addRedisBusinessDataSetComReqDto.setBusinessDataObject("KPI_TARGET_CALC_MQ_REMOTE_CONTROLLER");//sourceId:1837765_1_69485
                addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1837767_1_69485
                addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1837768_1_69485
                addRedisBusinessDataSetComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1837769_1_69485
                addRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1837771_1_69485
                addRedisBusinessDataSetComReqDto.setCustomFieldValue2("0");//CUSTOM_CONVENTION//sourceId:1837772_1_69485
                addRedisBusinessDataSetComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1837773_1_69485
                addRedisBusinessDataSetComReqDto.setCustomFieldValue3("0");//CUSTOM_CONVENTION//sourceId:1837774_1_69485
                addRedisBusinessDataSetComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1837775_1_69485
                addRedisBusinessDataSetComReqDto.setCustomFieldValue4("FALSE");//CUSTOM_CONVENTION//sourceId:1837776_1_69485
                addRedisBusinessDataSetComReqDto.setCustomField5("MQ_REMOTE_CONTROLLER_NAME");//CUSTOM_CONVENTION//sourceId:1837777_1_69485
                addRedisBusinessDataSetComReqDto.setCustomFieldValue5("KPI_TARGET_CALC");//CUSTOM_CONVENTION//sourceId:1837778_1_69485
                addRedisBusinessDataSetComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1837779_1_69485
                addRedisBusinessDataSetComReqDto.setCustomFieldValue6(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1837780_1_69485
                addRedisBusinessDataSetComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1837781_1_69485
                addRedisBusinessDataSetComReqDto.setCustomField8("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:1837783_1_69485
                addRedisBusinessDataSetComReqDto.setCustomField9("isOpenSymbolicAchievements");//CUSTOM_CONVENTION//sourceId:1837785_1_69485
                if (reqDto != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1837770_1_69485
                }
                if (receptionServiceRes != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue7(DateUtil.format(receptionServiceRes.getOperateTime(), "yyyy-MM-dd HH:mm:ss"));//SimpleFieldAssign//sourceId:1837782_1_69485
                }
                if (preparationKpiTargetCalcConfParametersComRespDto != null) {
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue8(preparationKpiTargetCalcConfParametersComRespDto.getTargetScoreUnit());//SimpleFieldAssign//sourceId:1837784_1_69485
                    addRedisBusinessDataSetComReqDto.setCustomFieldValue9(preparationKpiTargetCalcConfParametersComRespDto.getIsOpenSymbolicAchievements());//SimpleFieldAssign//sourceId:1837786_1_69485
                }

                /*D2增绩效目标计算MQ遥控器Redis[8399]   */
                Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-Redis数据对象目录不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-业务数据对象不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-是否删除redis历史数据不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-是否是数据集对象不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段1不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值1不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段2不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue2(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值2不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段3不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值3不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段4不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值4不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段5不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值5不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段6不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值6不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段7不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值7不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段8不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值8不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段9不能为空", false);
                Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(), "D2新增绩效目标计算MQ遥控器(公共)-D2增绩效目标计算MQ遥控器Redis-自定义字段值9不能为空", false);
                addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


            }
        }
        AddKpiTargetCalcMqRemoteControllerComRespDto retData = new AddKpiTargetCalcMqRemoteControllerComRespDto();


        return retData;
    }

    /**
     * D2准备OKR目标计算配置参数(公共)[9703]
     * gen by moon at 6/2/2024, 12:24:23 AM
     */
    @Trace(operationName = "D2准备OKR目标计算配置参数(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public PreparationOkrTargetCalcConfParametersComRespDto preparationOkrTargetCalcConfParametersCom(PreparationOkrTargetCalcConfParametersComReqDto reqDto) {


        ImplementTenReceivingFieldRespDto receptionServiceRes_2 = null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834894_1
        }

        /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D2准备OKR目标计算配置参数(公共)-M2接收入参字段-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1834917_1
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("TARGET_FULL_MARK_UNIT");//CUSTOM_CONVENTION//sourceId:1834918_1
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1834919_1
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1834916_1
        }

        /*D2查询评价模板目标得分配置答案[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D2准备OKR目标计算配置参数(公共)-D2查询评价模板目标得分配置答案-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(), "D2准备OKR目标计算配置参数(公共)-D2查询评价模板目标得分配置答案-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D2准备OKR目标计算配置参数(公共)-D2查询评价模板目标得分配置答案-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D2准备OKR目标计算配置参数(公共)-D2查询评价模板目标得分配置答案-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto)/*vcase invoke isSameApp*/;


//步骤2: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_1 = null;
        if (queryConfItemMatchAnswerDetailComRespDto != null) {
            ImplementTenReceivingFieldReqDto receptionServiceReq_1 = new ImplementTenReceivingFieldReqDto();
            if (queryConfItemMatchAnswerDetailComRespDto != null) {
                receptionServiceReq_1.setTargetScoreUnit(queryConfItemMatchAnswerDetailComRespDto.getConfOptionName());//SimpleFieldAssign//sourceId:1835074_1
            }

            /*M2接收配置参数出参[8782]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getTargetScoreUnit(), "D2准备OKR目标计算配置参数(公共)-M2接收配置参数出参-目标得分单位不能为空", false);
            receptionServiceRes_1 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_1);


            receptionServiceRes_2 = receptionServiceRes_1;
        }

        PreparationOkrTargetCalcConfParametersComRespDto retData = new PreparationOkrTargetCalcConfParametersComRespDto();
        if (receptionServiceRes_2 != null) {
            retData.setTargetScoreUnit(receptionServiceRes_2.getTargetScoreUnit());//SimpleFieldAssign//sourceId:1835075_1
        }


        return retData;
    }

    /**
     * D2准备绩效目标计算配置参数(公共)[9705]
     * gen by moon at 6/2/2024, 12:24:50 AM
     */
    @Trace(operationName = "D2准备绩效目标计算配置参数(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public PreparationKpiTargetCalcConfParametersComRespDto preparationKpiTargetCalcConfParametersCom(PreparationKpiTargetCalcConfParametersComReqDto reqDto) {


        ImplementTenReceivingFieldRespDto receptionServiceRes_2 = null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1836483_1
        }

        /*M2接收字段入参[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D2准备绩效目标计算配置参数(公共)-M2接收字段入参-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//步骤1: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto.setResultAspObjType("EVA_TEMP");//sourceId:1837324_1
        queryConfItemMatchAnswerDetailComReqDto.setConfItemCode("TARGET_FULL_MARK_UNIT");//CUSTOM_CONVENTION//sourceId:1837325_1
        queryConfItemMatchAnswerDetailComReqDto.setIsPlatData("FALSE");//sourceId:1837326_1
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1837323_1
        }

        /*D2查评价模板目标得分单位配置参数（公共）[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjId(), "D2准备绩效目标计算配置参数(公共)-D2查评价模板目标得分单位配置参数（公共）-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getResultAspObjType(), "D2准备绩效目标计算配置参数(公共)-D2查评价模板目标得分单位配置参数（公共）-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getConfItemCode(), "D2准备绩效目标计算配置参数(公共)-D2查评价模板目标得分单位配置参数（公共）-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto.getIsPlatData(), "D2准备绩效目标计算配置参数(公共)-D2查评价模板目标得分单位配置参数（公共）-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D2-3查配置项匹配答案详情(公共)（跨服务） - queryConfItemMatchAnswerDetailCom
        QueryConfItemMatchAnswerDetailComRespDto queryConfItemMatchAnswerDetailComRespDto_2 = null;
        QueryConfItemMatchAnswerDetailComReqDto queryConfItemMatchAnswerDetailComReqDto_1 = new QueryConfItemMatchAnswerDetailComReqDto();
        queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjType("EVA_TEMP");//sourceId:1837329_1
        queryConfItemMatchAnswerDetailComReqDto_1.setConfItemCode("IS_OPEN_SYMBOLIC_ACHIEVEMENTS");//CUSTOM_CONVENTION//sourceId:1837330_1
        queryConfItemMatchAnswerDetailComReqDto_1.setIsPlatData("FALSE");//sourceId:1837331_1
        if (reqDto != null) {
            queryConfItemMatchAnswerDetailComReqDto_1.setResultAspObjId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1837328_1
        }

        /*D2查询评价模板是否开启标志性成果配置参数（公共）[2486]   */
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjId(), "D2准备绩效目标计算配置参数(公共)-D2查询评价模板是否开启标志性成果配置参数（公共）-开通对象ID不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getResultAspObjType(), "D2准备绩效目标计算配置参数(公共)-D2查询评价模板是否开启标志性成果配置参数（公共）-开通对象类型编码不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getConfItemCode(), "D2准备绩效目标计算配置参数(公共)-D2查询评价模板是否开启标志性成果配置参数（公共）-配置项标识不能为空", false);
        Assert.isNull(queryConfItemMatchAnswerDetailComReqDto_1.getIsPlatData(), "D2准备绩效目标计算配置参数(公共)-D2查询评价模板是否开启标志性成果配置参数（公共）-是否标准答案不能为空", false);
        queryConfItemMatchAnswerDetailComRespDto_2 = confSchemeService.queryConfItemMatchAnswerDetailCom(queryConfItemMatchAnswerDetailComReqDto_1)/*vcase invoke isSameApp*/;


//步骤3: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_1 = null;
        if (queryConfItemMatchAnswerDetailComRespDto != null) {
            ImplementTenReceivingFieldReqDto receptionServiceReq_1 = new ImplementTenReceivingFieldReqDto();
            if (queryConfItemMatchAnswerDetailComRespDto != null) {
                receptionServiceReq_1.setTargetScoreUnit(queryConfItemMatchAnswerDetailComRespDto.getConfOptionName());//SimpleFieldAssign//sourceId:1837496_1
            }
            if (queryConfItemMatchAnswerDetailComRespDto_2 != null) {
                receptionServiceReq_1.setIsOpenSymbolicAchievements(queryConfItemMatchAnswerDetailComRespDto_2.getEndValue());//SimpleFieldAssign//sourceId:1837497_1
            }

            /*M2接收配置参数出参[8782]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getTargetScoreUnit(), "D2准备绩效目标计算配置参数(公共)-M2接收配置参数出参-目标得分单位不能为空", false);
            Assert.isNull(receptionServiceReq_1.getIsOpenSymbolicAchievements(), "D2准备绩效目标计算配置参数(公共)-M2接收配置参数出参-是否开启标志性成果不能为空", false);
            receptionServiceRes_1 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_1);


            receptionServiceRes_2 = receptionServiceRes_1;
        }

        PreparationKpiTargetCalcConfParametersComRespDto retData = new PreparationKpiTargetCalcConfParametersComRespDto();
        if (receptionServiceRes_2 != null) {
            retData.setTargetScoreUnit(receptionServiceRes_2.getTargetScoreUnit());//SimpleFieldAssign//sourceId:1837499_1
            retData.setIsOpenSymbolicAchievements(receptionServiceRes_2.getIsOpenSymbolicAchievements());//SimpleFieldAssign//sourceId:1837500_1
        }


        return retData;
    }

    /**
     * D2查询单遥控器Redis详情(公共)[9708]
     * gen by moon at 6/9/2024, 9:35:34 PM
     */
    @Trace(operationName = "D2查询单遥控器Redis详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QuerySingleRemoteControllerRedisDetailComRespDto querySingleRemoteControllerRedisDetailCom(QuerySingleRemoteControllerRedisDetailComReqDto reqDto) {


        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 = null;
//步骤0: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
        QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto = new QueryRefRedisBusinessDataSetDetailComReqDto();
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839409_1
        if (reqDto != null) {
            queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1839405_1
            queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue(reqDto.getRedisDataObjectCatalogue());//SimpleFieldAssign//sourceId:1839406_1
            queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1(reqDto.getRefCustomField1());//SimpleFieldAssign//sourceId:1839407_1
            queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1839408_1
            queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField2(reqDto.getRefCustomField2());//SimpleFieldAssign//sourceId:1861427_1
            queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue2(reqDto.getRefCustomFieldValue2());//SimpleFieldAssign//sourceId:1861428_1
        }

        /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D2查询单遥控器Redis详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D2查询单遥控器Redis详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField1(), "D2查询单遥控器Redis详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段1不能为空", false);
        queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


        queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

        QuerySingleRemoteControllerRedisDetailComRespDto retData = new QuerySingleRemoteControllerRedisDetailComRespDto();
        if (queryRefRedisBusinessDataSetDetailComRespDto_1 != null) {
            retData.setEvaluationTemplateId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField1());//SimpleFieldAssign//sourceId:1839414_1
        }


        return retData;
    }

    /**
     * D2执行Redis长生守护(公共)[9702]
     * gen by moon at 6/2/2024, 11:03:46 PM
     */
    @Trace(operationName = "D2执行Redis长生守护(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementRedisLongevityGuardianComRespDto implementRedisLongevityGuardianCom(ImplementRedisLongevityGuardianComReqDto reqDto) {


        //virtualUsage M2约定：Redis业务数据对象  69504
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        receptionServiceReq.setCustomField1("PLAN_TARGET_CALC_MQ_QUEUE");//CUSTOM_CONVENTION//sourceId:1840345_1_69504
        receptionServiceReq.setCustomField2("OKR_PLAN_TARGET_CALC_MQ_QUEUE");//CUSTOM_CONVENTION//sourceId:1840346_1_69504
        receptionServiceReq.setCustomField3("KPI_PLAN_TARGET_CALC_MQ_QUEUE");//CUSTOM_CONVENTION//sourceId:1840347_1_69504
        receptionServiceReq.setCustomField4("FINANCIAL_CALC_MQ_QUEUE");//CUSTOM_CONVENTION//sourceId:1840365_1_69504

        /*M2约定：Redis业务数据对象[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getCustomField1(), "D2执行Redis长生守护(公共)-M2约定：Redis业务数据对象-自定义字段1不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField2(), "D2执行Redis长生守护(公共)-M2约定：Redis业务数据对象-自定义字段2不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField3(), "D2执行Redis长生守护(公共)-M2约定：Redis业务数据对象-自定义字段3不能为空", false);
        Assert.isNull(receptionServiceReq.getCustomField4(), "D2执行Redis长生守护(公共)-M2约定：Redis业务数据对象-自定义字段4不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//virtualUsage D2查询有排队的遥控器详情(redis)  69495
        QueryQueueingRemoteControllerDetailComRespDto queryQueueingRemoteControllerDetailComRespDto = null;
        QueryQueueingRemoteControllerDetailComReqDto queryQueueingRemoteControllerDetailComReqDto = new QueryQueueingRemoteControllerDetailComReqDto();


        /*D2查询有排队的遥控器详情(redis)[9710]   */

        queryQueueingRemoteControllerDetailComRespDto = queryQueueingRemoteControllerDetailCom(queryQueueingRemoteControllerDetailComReqDto)/*vcase invoke 同服务,同domain*/;


        if ((queryQueueingRemoteControllerDetailComRespDto != null && queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId() != null && queryQueueingRemoteControllerDetailComRespDto != null && Long.valueOf(queryQueueingRemoteControllerDetailComRespDto.getQueueMinimum()) > 0)) {
            //if((D2查询有排队的遥控器详情(redis).评价模板ID 值不等于空  and D2查询有排队的遥控器详情(redis).排队最小值 大于 0))  69496

            if ((queryQueueingRemoteControllerDetailComRespDto != null && queryQueueingRemoteControllerDetailComRespDto.getMqRemoteControllerName() != null && queryQueueingRemoteControllerDetailComRespDto.getMqRemoteControllerName().equals("PLAN_TARGET_CALC"))) {
                //if(D2查询有排队的遥控器详情(redis).MQ遥控器名称 等于 规划目标计算)  69499

                QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto = null;
                if (queryQueueingRemoteControllerDetailComRespDto != null) {
                    QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto = new QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto();
                    if (queryQueueingRemoteControllerDetailComRespDto != null) {
                        queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto.setEvaluationTemplateId(queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1840419_1_69506
                    }

                    /*D2查询规划目标计算MQ遥控器公共业务数据(Redis)[9711]   */
                    Assert.isNull(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto.getEvaluationTemplateId(), "D2执行Redis长生守护(公共)-D2查询规划目标计算MQ遥控器公共业务数据(Redis)-冗余评价模板ID不能为空", false);
                    queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto = queryPlanTargetCalcMqRemoteControllerBusinessDataDetailCom(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto)/*vcase invoke 同服务,同domain*/;


                }
                QueryRemoteControllerQueueConDataDetailComRespDto queryRemoteControllerQueueConDataDetailComRespDto = null;
                if (queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto != null) {
                    QueryRemoteControllerQueueConDataDetailComReqDto queryRemoteControllerQueueConDataDetailComReqDto = new QueryRemoteControllerQueueConDataDetailComReqDto();
                    if (receptionServiceRes != null) {
                        queryRemoteControllerQueueConDataDetailComReqDto.setBusinessDataObject(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1841105_1_69517
                    }
                    if (queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto != null) {
                        queryRemoteControllerQueueConDataDetailComReqDto.setDataObjectBatchCode(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto.getCustomField1());//SimpleFieldAssign//sourceId:1841106_1_69517
                        queryRemoteControllerQueueConDataDetailComReqDto.setRefCustomFieldValue1(String.valueOf(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto.getQueueMinimum()));//SimpleFieldAssign//sourceId:1841107_1_69517
                    }

                    /*D2查询MQ排队计算内容数据详情(公共)[9712]   */
                    Assert.isNull(queryRemoteControllerQueueConDataDetailComReqDto.getBusinessDataObject(), "D2执行Redis长生守护(公共)-D2查询MQ排队计算内容数据详情(公共)-业务数据对象不能为空", false);
                    Assert.isNull(queryRemoteControllerQueueConDataDetailComReqDto.getDataObjectBatchCode(), "D2执行Redis长生守护(公共)-D2查询MQ排队计算内容数据详情(公共)-数据对象批次标识不能为空", false);
                    Assert.isNull(queryRemoteControllerQueueConDataDetailComReqDto.getRefCustomFieldValue1(), "D2执行Redis长生守护(公共)-D2查询MQ排队计算内容数据详情(公共)-排队值不能为空", false);
                    queryRemoteControllerQueueConDataDetailComRespDto = queryRemoteControllerQueueConDataDetailCom(queryRemoteControllerQueueConDataDetailComReqDto)/*vcase invoke 同服务,同domain*/;


                }
                if ((queryRemoteControllerQueueConDataDetailComRespDto != null && queryRemoteControllerQueueConDataDetailComRespDto.getTargetAttributionCycleId() != null)) {
                    //if(D2查询MQ排队计算内容数据详情(公共).目标归属周期ID 值不等于空 )  69518

                    ImplementCurQueueOutWriteMiniComRespDto implementCurQueueOutWriteMiniComRespDto = null;
                    if (queryQueueingRemoteControllerDetailComRespDto != null && queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto != null) {
                        ImplementCurQueueOutWriteMiniComReqDto implementCurQueueOutWriteMiniComReqDto = new ImplementCurQueueOutWriteMiniComReqDto();
                        implementCurQueueOutWriteMiniComReqDto.setControlBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1842877_1_69527
                        implementCurQueueOutWriteMiniComReqDto.setCommPrimaryKeyFieldName("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1842882_1_69527
                        if (receptionServiceRes != null) {
                            implementCurQueueOutWriteMiniComReqDto.setQueueBusinessDataObject(receptionServiceRes.getCustomField1());//SimpleFieldAssign//sourceId:1842878_1_69527
                        }
                        if (queryQueueingRemoteControllerDetailComRespDto != null) {
                            implementCurQueueOutWriteMiniComReqDto.setDataObjectBatchCode(queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1842879_1_69527
                            implementCurQueueOutWriteMiniComReqDto.setCommPrimaryKey(queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1842881_1_69527
                        }
                        if (queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto != null) {
                            implementCurQueueOutWriteMiniComReqDto.setQueueMinimum(queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto.getQueueMinimum());//SimpleFieldAssign//sourceId:1842880_1_69527
                        }

                        /*D2执行当前排队移出回写最小排队值(redis)[9716]   */
                        Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getControlBusinessDataObject(), "D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-MQ遥控器业务数据对象不能为空", false);
                        Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getQueueBusinessDataObject(), "D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-MQ队列业务数据对象不能为空", false);
                        Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getDataObjectBatchCode(), "D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-数据对象批次标识不能为空", false);
                        Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getCommPrimaryKey(), "D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-通用主键ID不能为空", false);
                        Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getCommPrimaryKeyFieldName(), "D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-通用主键字段名不能为空", false);
                        Assert.isNull(implementCurQueueOutWriteMiniComReqDto.getQueueMinimum(), "D2执行Redis长生守护(公共)-D2执行当前排队移出回写最小排队值(redis)-排队最小值不能为空", false);
                        implementCurQueueOutWriteMiniComRespDto = implementCurQueueOutWriteMiniCom(implementCurQueueOutWriteMiniComReqDto)/*vcase invoke 同服务,同domain*/;


                    }
                } else if ((queryRemoteControllerQueueConDataDetailComRespDto != null && queryRemoteControllerQueueConDataDetailComRespDto.getTargetAttributionCycleId() == null)) {
                    //elseif(D2查询MQ排队计算内容数据详情(公共).目标归属周期ID 值等于空 )  69519

                    ImplementRemoteControllerResetZeroComRespDto implementRemoteControllerResetZeroComRespDto = null;
                    if (queryQueueingRemoteControllerDetailComRespDto != null) {
                        ImplementRemoteControllerResetZeroComReqDto implementRemoteControllerResetZeroComReqDto = new ImplementRemoteControllerResetZeroComReqDto();
                        implementRemoteControllerResetZeroComReqDto.setCommPrimaryKeyFieldName("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1846063_1_69544
                        if (queryQueueingRemoteControllerDetailComRespDto != null) {
                            implementRemoteControllerResetZeroComReqDto.setCommPrimaryKey(queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1846062_1_69544
                        }

                        /*D2执行MQ遥控器重置为0(公共)[9722]   */
                        Assert.isNull(implementRemoteControllerResetZeroComReqDto.getCommPrimaryKey(), "D2执行Redis长生守护(公共)-D2执行MQ遥控器重置为0(公共)-通用主键ID不能为空", false);
                        Assert.isNull(implementRemoteControllerResetZeroComReqDto.getCommPrimaryKeyFieldName(), "D2执行Redis长生守护(公共)-D2执行MQ遥控器重置为0(公共)-通用主键字段名不能为空", false);
                        implementRemoteControllerResetZeroComRespDto = implementRemoteControllerResetZeroCom(implementRemoteControllerResetZeroComReqDto)/*vcase invoke 同服务,同domain*/;


                    }
                }
                if ((queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto != null && queryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto.getCustomField1() == null)) {
                    //if(D2查询规划目标计算MQ遥控器公共业务数据(Redis).评价模板ID 值等于空 )  69507

//异常结束 69510
                    throw new BizException("C221000450", "对不起，找不到当前评价模板ID的规划目标计算的MQ遥控器~", false);
                }
            }
        } else if ((queryQueueingRemoteControllerDetailComRespDto != null && queryQueueingRemoteControllerDetailComRespDto.getEvaluationTemplateId() != null && queryQueueingRemoteControllerDetailComRespDto != null && queryQueueingRemoteControllerDetailComRespDto.getQueueMinimum() != null && queryQueueingRemoteControllerDetailComRespDto.getQueueMinimum().equals("0"))) {
            //elseif((D2查询有排队的遥控器详情(redis).评价模板ID 值不等于空  and D2查询有排队的遥控器详情(redis).排队最小值 等于 0))  69532

//异常结束 69533
            throw new BizException("C221000451", "对不起，当前有MQ遥控器的排队，最小排队值不能为0~", false);
        }
        ImplementRedisLongevityGuardianComRespDto retData = new ImplementRedisLongevityGuardianComRespDto();


        return retData;
    }

    /**
     * D2查询有排队的遥控器详情(redis)[9710]
     * gen by moon at 6/9/2024, 9:35:18 PM
     */
    @Trace(operationName = "D2查询有排队的遥控器详情(redis)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryQueueingRemoteControllerDetailComRespDto queryQueueingRemoteControllerDetailCom(QueryQueueingRemoteControllerDetailComReqDto reqDto) {


        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 = null;
        ImplementTenReceivingFieldRespDto receptionServiceRes_1 = null;
//步骤0: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
        QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto = new QueryRefRedisBusinessDataSetDetailComReqDto();
        queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1861437_1
        queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839737_1
        queryRefRedisBusinessDataSetDetailComReqDto.setRedisParamSortType("ASC");//sourceId:1846408_1
        queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1839738_1
        queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1("TRUE");//CUSTOM_CONVENTION//sourceId:1839739_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839908_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1845575_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField5("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1839918_1

        /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisParamSortType(), "D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-redis出参排序类型不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(), "D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(), "D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField1(), "D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(), "D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段2不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField5(), "D2查询有排队的遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段5不能为空", false);
        queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


        queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

//步骤1: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        if (queryRefRedisBusinessDataSetDetailComRespDto != null) {
            ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
            if (queryRefRedisBusinessDataSetDetailComRespDto != null) {
                receptionServiceReq.setQueueMinimum(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2() != null ? Integer.valueOf(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2()) : null);//SimpleFieldAssign//sourceId:1847191_1
            }

            /*M2接收出参排队最小值[8782]  用于特殊方法接收上游入参。 */
//    Assert.isNull(receptionServiceReq.getQueueMinimum(),"D2查询有排队的遥控器详情(redis)-M2接收出参排队最小值-排队最小值不能为空",false);
            receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


            receptionServiceRes_1 = receptionServiceRes;
        }

        QueryQueueingRemoteControllerDetailComRespDto retData = new QueryQueueingRemoteControllerDetailComRespDto();
        if (queryRefRedisBusinessDataSetDetailComRespDto_1 != null) {
            retData.setEvaluationTemplateId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField1());//SimpleFieldAssign//sourceId:1839914_1
            retData.setMqRemoteControllerName(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField5());//SimpleFieldAssign//sourceId:1839920_1
        }
        if (receptionServiceRes_1 != null) {
            retData.setQueueMinimum(receptionServiceRes_1.getQueueMinimum() != null ? receptionServiceRes_1.getQueueMinimum().intValue() : null);//SimpleFieldAssign//sourceId:1847192_1
        }


        return retData;
    }

    /**
     * D2查询规划目标计算MQ遥控器公共业务数据(Redis)[9711]
     * gen by moon at 7/2/2024, 3:19:45 AM
     */
    @Trace(operationName = "D2查询规划目标计算MQ遥控器公共业务数据(Redis)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto queryPlanTargetCalcMqRemoteControllerBusinessDataDetailCom(QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComReqDto reqDto) {


        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 = null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839900_1
        }

        /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-M2接收入参字段-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//步骤1: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
        QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto = new QueryRefRedisBusinessDataSetDetailComReqDto();
        queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1839616_1
        queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1839498_1
        queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839500_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1839508_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1839509_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1839510_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1839511_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField5("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1839512_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1839513_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1839514_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField8("isAllowBudgetOverruns");//CUSTOM_CONVENTION//sourceId:1839515_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField9("cashAccountUnit");//CUSTOM_CONVENTION//sourceId:1839516_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField10("isOpenFinance");//CUSTOM_CONVENTION//sourceId:1839517_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField11("schemeDataPara");//CUSTOM_CONVENTION//sourceId:1839518_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField12("isOkrPlanScene");//CUSTOM_CONVENTION//sourceId:1839519_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField13("reportType");//CUSTOM_CONVENTION//sourceId:1839520_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField14("cycleMode");//CUSTOM_CONVENTION//sourceId:1839521_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField15("fatherCycleType");//CUSTOM_CONVENTION//sourceId:1839522_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField16("subcycleType");//CUSTOM_CONVENTION//sourceId:1839523_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField17("midCycleType");//CUSTOM_CONVENTION//sourceId:1839524_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField18("openMidCycle");//CUSTOM_CONVENTION//sourceId:1839525_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField19("lastCycleType");//CUSTOM_CONVENTION//sourceId:1839526_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField20("secondLastCycleType");//CUSTOM_CONVENTION//sourceId:1839527_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField21("isOpenMidProcess");//CUSTOM_CONVENTION//sourceId:1839528_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField22("processMidCycleType");//CUSTOM_CONVENTION//sourceId:1839529_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField23("isOpenSubReportLimit");//CUSTOM_CONVENTION//sourceId:1839530_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField24("constTaskIsOpenReport");//CUSTOM_CONVENTION//sourceId:1839531_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField25("constIsOpenAtuoReport");//CUSTOM_CONVENTION//sourceId:1839532_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField26("noPracticalValueObjIsProgReport");//CUSTOM_CONVENTION//sourceId:1839533_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField27("objectiveActualScoreIsOpenLocalLevelScore");//CUSTOM_CONVENTION//sourceId:1839534_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField28("actualScoreIsOpenLocalLevelScore");//CUSTOM_CONVENTION//sourceId:1839535_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField29("actualScoreFormula");//CUSTOM_CONVENTION//sourceId:1839536_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField30("subjectiveRatingTotalValue");//CUSTOM_CONVENTION//sourceId:1839537_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField31("subjectiveFullMarkUnit");//CUSTOM_CONVENTION//sourceId:1839538_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField32("scoreDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839539_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField33("degreeDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839540_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField34("progressDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839541_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField35("subjectiveScorePoint");//CUSTOM_CONVENTION//sourceId:1839542_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField36("weightPoint");//CUSTOM_CONVENTION//sourceId:1839543_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField37("weightDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839544_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField38("increasesDropDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839545_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField39("actualValueDecimalPoint");//CUSTOM_CONVENTION//sourceId:1839546_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField40("decimalDigitsLastRules");//CUSTOM_CONVENTION//sourceId:1839547_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField41("subjectiveScoreWeight");//CUSTOM_CONVENTION//sourceId:1839548_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField42("objectiveScoreWeight");//CUSTOM_CONVENTION//sourceId:1839549_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField43("processReportScoreMidWeight");//CUSTOM_CONVENTION//sourceId:1839550_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField44("processReportScoreProMidWeight");//CUSTOM_CONVENTION//sourceId:1839551_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField45("processReportScoreAvgWeight");//CUSTOM_CONVENTION//sourceId:1839552_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField46("reportScoreSubAndObjWeight");//CUSTOM_CONVENTION//sourceId:1839553_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField47("actualScoreLocalLevelWeight");//CUSTOM_CONVENTION//sourceId:1839554_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField48("actualScoreLowerLevelWeight");//CUSTOM_CONVENTION//sourceId:1839555_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField49("isOpenSymbolicAchievements");//CUSTOM_CONVENTION//sourceId:1839556_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField50("isOpenBudget");//CUSTOM_CONVENTION//sourceId:1839557_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField51("isOpenBudgetReport");//CUSTOM_CONVENTION//sourceId:1840373_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField52("useAccountSubjectType");//CUSTOM_CONVENTION//sourceId:1840374_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField53("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:1840375_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField54("isAllowBudgetOverruns");//CUSTOM_CONVENTION//sourceId:1840376_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField55("targetScoreUnit");//CUSTOM_CONVENTION//sourceId:1840377_1
        if (reqDto != null) {
            queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1839608_1
        }

        /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField1(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段2不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段3不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField4(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段4不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField5(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段5不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField6(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段6不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField7(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段7不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField8(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段8不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField9(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段9不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField10(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段10不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField11(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段11不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField12(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段12不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField13(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段13不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField14(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段14不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField15(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段15不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField16(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段16不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField17(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段17不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField18(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段18不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField19(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段19不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField20(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段20不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField21(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段21不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField22(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段22不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField23(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段23不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField24(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段24不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField25(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段25不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField26(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段26不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField27(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段27不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField28(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段28不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField29(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段29不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField30(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段30不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField31(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段31不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField32(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段32不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField33(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段33不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField34(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段34不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField35(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段35不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField36(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段36不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField37(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段37不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField38(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段38不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField39(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段39不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField40(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段40不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField41(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段41不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField42(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段42不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField43(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段43不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField44(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段44不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField45(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段45不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField46(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段46不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField47(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段47不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField48(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段48不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField49(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段49不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField50(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段50不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField51(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段51不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField52(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段52不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField53(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段53不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField54(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段54不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField55(), "D2查询规划目标计算MQ遥控器公共业务数据(Redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段55不能为空", false);
        queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


        queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

        QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto retData = new QueryPlanTargetCalcMqRemoteControllerBusinessDataDetailComRespDto();
        if (queryRefRedisBusinessDataSetDetailComRespDto_1 != null) {
            retData.setCustomField1(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField1());//SimpleFieldAssign//sourceId:1839902_1
            retData.setQueueMinimum(Integer.valueOf(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField2()));//SimpleFieldAssign//sourceId:1839903_1
            retData.setQueueMaximum(Integer.valueOf(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField3()));//SimpleFieldAssign//sourceId:1839904_1
            retData.setIsQueueCurrently(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField4());//SimpleFieldAssign//sourceId:1839905_1
            retData.setMqRemoteControllerName(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField5());//SimpleFieldAssign//sourceId:1839906_1
            retData.setOperationInductionId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField6());//SimpleFieldAssign//sourceId:1839907_1
            retData.setOperateTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField7());//SimpleFieldAssign//sourceId:1839910_1
            retData.setIsAllowBudgetOverruns(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField8());//SimpleFieldAssign//sourceId:1839913_1
            retData.setCashAccountUnit(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField9());//SimpleFieldAssign//sourceId:1839916_1
            retData.setIsOpenFinance(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField10());//SimpleFieldAssign//sourceId:1839917_1
            retData.setSchemeDataPara(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField11());//SimpleFieldAssign//sourceId:1839929_1
            retData.setIsOkrPlanScene(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField12());//SimpleFieldAssign//sourceId:1839930_1
            retData.setReportType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField13());//SimpleFieldAssign//sourceId:1839931_1
            retData.setCycleMode(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField14());//SimpleFieldAssign//sourceId:1839932_1
            retData.setFatherCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField15());//SimpleFieldAssign//sourceId:1839933_1
            retData.setSubCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField16());//SimpleFieldAssign//sourceId:1839934_1
            retData.setMidCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField17());//SimpleFieldAssign//sourceId:1839935_1
            retData.setOpenMidCycle(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField18());//SimpleFieldAssign//sourceId:1839936_1
            retData.setLastCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField19());//SimpleFieldAssign//sourceId:1839937_1
            retData.setSecondLastCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField20());//SimpleFieldAssign//sourceId:1839938_1
            retData.setIsOpenMidProcess(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField21());//SimpleFieldAssign//sourceId:1839939_1
            retData.setProcessMidCycleType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField22());//SimpleFieldAssign//sourceId:1839940_1
            retData.setIsOpenSubReportLimit(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField23());//SimpleFieldAssign//sourceId:1839941_1
            retData.setConstTaskIsOpenReport(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField24());//SimpleFieldAssign//sourceId:1839942_1
            retData.setConstIsOpenAtuoReport(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField25());//SimpleFieldAssign//sourceId:1839943_1
            retData.setNoPracticalValueObjIsProgReport(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField26());//SimpleFieldAssign//sourceId:1839944_1
            retData.setObjectiveActualScoreIsOpenLocalLevelScore(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField27());//SimpleFieldAssign//sourceId:1839945_1
            retData.setActualScoreIsOpenLocalLevelScore(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField28());//SimpleFieldAssign//sourceId:1839946_1
            retData.setActualScoreFormula(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField29());//SimpleFieldAssign//sourceId:1839947_1
            retData.setSubjectiveRatingTotalValue(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField30());//SimpleFieldAssign//sourceId:1839948_1
            retData.setSubjectiveFullMarkUnit(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField31());//SimpleFieldAssign//sourceId:1839949_1
            retData.setScoreDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField32());//SimpleFieldAssign//sourceId:1840022_1
            retData.setDegreeDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField33());//SimpleFieldAssign//sourceId:1840023_1
            retData.setProgressDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField34());//SimpleFieldAssign//sourceId:1840078_1
            retData.setSubjectiveScorePoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField35());//SimpleFieldAssign//sourceId:1840086_1
            retData.setWeightPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField36());//SimpleFieldAssign//sourceId:1840087_1
            retData.setWeightDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField37());//SimpleFieldAssign//sourceId:1840088_1
            retData.setIncreasesDropDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField38());//SimpleFieldAssign//sourceId:1840161_1
            retData.setActualValueDecimalPoint(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField39());//SimpleFieldAssign//sourceId:1840168_1
            retData.setDecimalDigitsLastRules(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField40());//SimpleFieldAssign//sourceId:1840172_1
            retData.setSubjectiveScoreWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField41());//SimpleFieldAssign//sourceId:1840173_1
            retData.setObjectiveScoreWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField42());//SimpleFieldAssign//sourceId:1840177_1
            retData.setProcessReportScoreMidWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField43());//SimpleFieldAssign//sourceId:1840179_1
            retData.setProcessReportScoreProMidWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField44());//SimpleFieldAssign//sourceId:1840180_1
            retData.setProcessReportScoreAvgWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField45());//SimpleFieldAssign//sourceId:1840181_1
            retData.setReportScoreSubAndObjWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField46());//SimpleFieldAssign//sourceId:1840342_1
            retData.setActualScoreLocalLevelWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField47());//SimpleFieldAssign//sourceId:1840343_1
            retData.setActualScoreLowerLevelWeight(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField48());//SimpleFieldAssign//sourceId:1840344_1
            retData.setIsOpenSymbolicAchievements(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField49());//SimpleFieldAssign//sourceId:1840351_1
            retData.setIsOpenBudget(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField50());//SimpleFieldAssign//sourceId:1840352_1
            retData.setIsOpenBudgetReport(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField51());//SimpleFieldAssign//sourceId:1840414_1
            retData.setUseAccountSubjectType(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField52());//SimpleFieldAssign//sourceId:1840415_1
            retData.setIsOpenFundsArrival(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField53());//SimpleFieldAssign//sourceId:1840416_1
            retData.setIsAllowBudgetOverruns(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField54());//SimpleFieldAssign//sourceId:1840417_1
            retData.setTargetScoreUnit(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField55());//SimpleFieldAssign//sourceId:1840418_1
        }


        return retData;
    }

    /**
     * D2查询MQ排队计算内容数据详情(公共)[9712]
     * gen by moon at 6/6/2024, 3:47:40 PM
     */
    @Trace(operationName = "D2查询MQ排队计算内容数据详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryRemoteControllerQueueConDataDetailComRespDto queryRemoteControllerQueueConDataDetailCom(QueryRemoteControllerQueueConDataDetailComReqDto reqDto) {


        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 = null;
//步骤0: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
        QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto = new QueryRefRedisBusinessDataSetDetailComReqDto();
        queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1841072_1
        queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:1841073_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("targetAttributionCycleId");//CUSTOM_CONVENTION//sourceId:1841083_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("isLastCycle");//CUSTOM_CONVENTION//sourceId:1841084_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField4("spaceId");//CUSTOM_CONVENTION//sourceId:1852115_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField5("appId");//CUSTOM_CONVENTION//sourceId:1852116_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1852117_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField7("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:1852118_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField8("updateCycleId");//CUSTOM_CONVENTION//sourceId:1852119_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField9("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:1852120_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField10("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:1852121_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField11("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:1852122_1
        if (reqDto != null) {
            queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1841071_1
            queryRefRedisBusinessDataSetDetailComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1841079_1
            queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1841074_1
        }

        /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getDataObjectBatchCode(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-数据对象批次标识不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段2不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段3不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField4(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段4不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField5(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段5不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField6(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段6不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField7(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段7不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField8(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段8不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField9(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段9不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField10(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段10不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField11(), "D2查询MQ排队计算内容数据详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段11不能为空", false);
        queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


        queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

        QueryRemoteControllerQueueConDataDetailComRespDto retData = new QueryRemoteControllerQueueConDataDetailComRespDto();
        if (queryRefRedisBusinessDataSetDetailComRespDto_1 != null) {
            retData.setTargetAttributionCycleId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField2());//SimpleFieldAssign//sourceId:1841098_1
            retData.setIsLastCycle(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField3());//SimpleFieldAssign//sourceId:1841099_1
            retData.setSpaceId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField4());//SimpleFieldAssign//sourceId:1849435_1
            retData.setAppId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField5());//SimpleFieldAssign//sourceId:1849436_1
            retData.setOperationInductionId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField6());//SimpleFieldAssign//sourceId:1849437_1
            retData.setPreUpdateCycleId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField7());//SimpleFieldAssign//sourceId:1852128_1
            retData.setUpdateCycleId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField8());//SimpleFieldAssign//sourceId:1852129_1
            retData.setUpdateCycleStartTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField9());//SimpleFieldAssign//sourceId:1852130_1
            retData.setUpdateCycleEndTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField10());//SimpleFieldAssign//sourceId:1852131_1
            retData.setUpdateCycleTypeCode(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField11());//SimpleFieldAssign//sourceId:1852132_1
        }


        return retData;
    }

    /**
     * D2执行当前排队移出回写最小排队值(redis)[9716]
     * gen by moon at 6/6/2024, 8:52:02 PM
     */
    @Trace(operationName = "D2执行当前排队移出回写最小排队值(redis)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementCurQueueOutWriteMiniComRespDto implementCurQueueOutWriteMiniCom(ImplementCurQueueOutWriteMiniComReqDto reqDto) {


        //步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setControlBusinessDataObject(reqDto.getControlBusinessDataObject());//SimpleFieldAssign//sourceId:1842070_1
            receptionServiceReq.setQueueBusinessDataObject(reqDto.getQueueBusinessDataObject());//SimpleFieldAssign//sourceId:1842071_1
            receptionServiceReq.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1842067_1
            receptionServiceReq.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1842869_1
            receptionServiceReq.setCommPrimaryKeyFieldName(reqDto.getCommPrimaryKeyFieldName());//SimpleFieldAssign//sourceId:1842875_1
            receptionServiceReq.setQueueMinimum(reqDto.getQueueMinimum() != null ? Integer.valueOf(reqDto.getQueueMinimum()) : null);//SimpleFieldAssign//sourceId:1842866_1
        }

        /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getControlBusinessDataObject(), "D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-MQ遥控器业务数据对象不能为空", false);
        Assert.isNull(receptionServiceReq.getQueueBusinessDataObject(), "D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-MQ队列业务数据对象不能为空", false);
        Assert.isNull(receptionServiceReq.getDataObjectBatchCode(), "D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-数据对象批次标识不能为空", false);
        Assert.isNull(receptionServiceReq.getCommPrimaryKey(), "D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-通用主键ID不能为空", false);
        Assert.isNull(receptionServiceReq.getCommPrimaryKeyFieldName(), "D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-通用主键字段名不能为空", false);
        Assert.isNull(receptionServiceReq.getQueueMinimum(), "D2执行当前排队移出回写最小排队值(redis)-M2接收入参字段-排队最小值不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//步骤1: D2删除redis业务数据对象(业务原子) - deleteRedisBusinessDataSetCom
        DeleteRedisBusinessDataSetComRespDto deleteRedisBusinessDataSetComRespDto = null;
        DeleteRedisBusinessDataSetComReqDto deleteRedisBusinessDataSetComReqDto = new DeleteRedisBusinessDataSetComReqDto();
        deleteRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1841880_1
        deleteRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1841883_1
        deleteRedisBusinessDataSetComReqDto.setCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:1841884_1
        if (reqDto != null) {
            deleteRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getQueueBusinessDataObject());//SimpleFieldAssign//sourceId:1841881_1
            deleteRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1841882_1
            deleteRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getQueueMinimum() != null ? String.valueOf(reqDto.getQueueMinimum()) : "");//SimpleFieldAssign//sourceId:1841885_1
        }

        /*D2删除MQ排队当前值的队列数据[9717]   */
        Assert.isNull(deleteRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-Redis数据对象目录不能为空", false);
        Assert.isNull(deleteRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-业务数据对象不能为空", false);
        Assert.isNull(deleteRedisBusinessDataSetComReqDto.getDataObjectBatchCode(), "D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-数据对象批次标识不能为空", false);
        Assert.isNull(deleteRedisBusinessDataSetComReqDto.getIsDataList(), "D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-是否是数据集对象不能为空", false);
        Assert.isNull(deleteRedisBusinessDataSetComReqDto.getCustomField1(), "D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-自定义字段1不能为空", false);
        Assert.isNull(deleteRedisBusinessDataSetComReqDto.getCustomFieldValue1(), "D2执行当前排队移出回写最小排队值(redis)-D2删除MQ排队当前值的队列数据-自定义字段值1不能为空", false);
        deleteRedisBusinessDataSetComRespDto = businessAtomService.deleteRedisBusinessDataSetCom(deleteRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D2-计算两个数值相加(公共) - calculateAdditionOfTwoNumsCom
        CalculateAdditionOfTwoNumsComRespDto calculateAdditionOfTwoNumsComRespDto = null;
        CalculateAdditionOfTwoNumsComReqDto calculateAdditionOfTwoNumsComReqDto = new CalculateAdditionOfTwoNumsComReqDto();
        calculateAdditionOfTwoNumsComReqDto.setCalcPara2(Double.valueOf("1"));//CUSTOM_CONVENTION//sourceId:1842872_1
        if (reqDto != null) {
            calculateAdditionOfTwoNumsComReqDto.setCalcPara1(reqDto.getQueueMinimum() != null ? Double.valueOf(reqDto.getQueueMinimum()) : null);//SimpleFieldAssign//sourceId:1842871_1
        }

        /*D2当前排队最小值+1[8137]   */
        Assert.isNull(calculateAdditionOfTwoNumsComReqDto.getCalcPara1(), "D2执行当前排队移出回写最小排队值(redis)-D2当前排队最小值+1-计算入参1不能为空", false);
        Assert.isNull(calculateAdditionOfTwoNumsComReqDto.getCalcPara2(), "D2执行当前排队移出回写最小排队值(redis)-D2当前排队最小值+1-计算入参2不能为空", false);
        calculateAdditionOfTwoNumsComRespDto = interfaceModeService.calculateAdditionOfTwoNumsCom(calculateAdditionOfTwoNumsComReqDto)/*vcase invoke isSameApp*/;


//步骤3: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes_1 = null;
        if (calculateAdditionOfTwoNumsComRespDto != null) {
            ImplementTenReceivingFieldReqDto receptionServiceReq_1 = new ImplementTenReceivingFieldReqDto();
            if (calculateAdditionOfTwoNumsComRespDto != null) {
                // TODO: 2024/6/6
                receptionServiceReq_1.setQueueMinimum(calculateAdditionOfTwoNumsComRespDto.getCalcResult() != null ? calculateAdditionOfTwoNumsComRespDto.getCalcResult().intValue() : null);//SimpleFieldAssign//sourceId:1853010_1
            }

            /*M2接收排队最小值（小数转整数，接口锁定）[8782]  用于特殊方法接收上游入参。 */
            Assert.isNull(receptionServiceReq_1.getQueueMinimum(), "D2执行当前排队移出回写最小排队值(redis)-M2接收排队最小值（小数转整数，接口锁定）-排队最小值不能为空", false);
            receptionServiceRes_1 = nbEvaCalc.implementTenReceivingField(receptionServiceReq_1);


        }

//步骤4: D2修改redis业务数据对象(业务原子) - updateRedisBusinessDataSetCom
        UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto = null;
        UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto = new UpdateRedisBusinessDataSetComReqDto();
        updateRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1841900_1
        updateRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1841902_1
        updateRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1841905_1
        if (reqDto != null) {
            updateRedisBusinessDataSetComReqDto.setBusinessDataObject(reqDto.getControlBusinessDataObject());//SimpleFieldAssign//sourceId:1841901_1
            updateRedisBusinessDataSetComReqDto.setRefCustomField1(reqDto.getCommPrimaryKeyFieldName());//SimpleFieldAssign//sourceId:1841903_1
            updateRedisBusinessDataSetComReqDto.setRefCustomFieldValue1(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1841904_1
        }
        if (receptionServiceRes_1 != null) {
            updateRedisBusinessDataSetComReqDto.setCustomFieldValue2(receptionServiceRes_1.getQueueMinimum() != null ? String.valueOf(receptionServiceRes_1.getQueueMinimum()) : "");//SimpleFieldAssign//sourceId:1841906_1
        }

        /*D2修改MQ遥控器排队值[9407]   */
        Assert.isNull(updateRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-Redis数据对象目录不能为空", false);
        Assert.isNull(updateRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-业务数据对象不能为空", false);
        Assert.isNull(updateRedisBusinessDataSetComReqDto.getIsDataList(), "D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-是否是数据集对象不能为空", false);
        Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomField1(), "D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-入参自定义字段1不能为空", false);
        Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomFieldValue1(), "D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-入参自定义字段值1不能为空", false);
        Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField2(), "D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-自定义字段2不能为空", false);
        Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue2(), "D2执行当前排队移出回写最小排队值(redis)-D2修改MQ遥控器排队值-自定义字段值2不能为空", false);
        updateRedisBusinessDataSetComRespDto = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


        ImplementCurQueueOutWriteMiniComRespDto retData = new ImplementCurQueueOutWriteMiniComRespDto();


        return retData;
    }

    /**
     * D2执行MQ遥控器重置为0(公共)[9722]
     * gen by moon at 6/8/2024, 8:04:37 PM
     */
    @Trace(operationName = "D2执行MQ遥控器重置为0(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementRemoteControllerResetZeroComRespDto implementRemoteControllerResetZeroCom(ImplementRemoteControllerResetZeroComReqDto reqDto) {


        //virtualUsage D2执行分布式加锁  69529
        ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto = null;
        ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto = new ImplementConcBhvThemeLockComComReqDto();
        implementConcBhvThemeLockComComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1843207_1_69529
        implementConcBhvThemeLockComComReqDto.setBehaviorThemeLockCode("MQ_HOVER_QUEUE_LOCK");//sourceId:1843197_1_69529
        implementConcBhvThemeLockComComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1843196_1_69529
        implementConcBhvThemeLockComComReqDto.setDuration(Long.valueOf(5));//CUSTOM_CONVENTION//sourceId:1843202_1_69529
        implementConcBhvThemeLockComComReqDto.setTimeUnitType("MINUTES");//sourceId:1843203_1_69529
        implementConcBhvThemeLockComComReqDto.setHandlingMethodConcurrentLockFailure("CONCURRENT_LOCK_FAILURE_NO_ERROR_REPORTED");//sourceId:1843204_1_69529
        implementConcBhvThemeLockComComReqDto.setWhetherUnlockBulk("FALSE");//sourceId:1843205_1_69529
        if (reqDto != null) {
            implementConcBhvThemeLockComComReqDto.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1843198_1_69529
        }

        /*D2执行分布式加锁[8388]   */
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getRedisDataObjectCatalogue(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-Redis数据对象目录不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getBehaviorThemeLockCode(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-行为主题锁业务数据对象不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getCommPrimaryKey(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-通用主键ID不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getPreventConcurrentLockingUnlocking(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getDuration(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-锁定时长不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getTimeUnitType(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-时间单位类型不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getHandlingMethodConcurrentLockFailure(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-并发上锁失败处理方式不能为空", false);
        Assert.isNull(implementConcBhvThemeLockComComReqDto.getWhetherUnlockBulk(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式加锁-是否批量解锁不能为空", false);
        implementConcBhvThemeLockComComRespDto = interfaceModeService.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto)/*vcase invoke isSameApp*/;


        if ((implementConcBhvThemeLockComComRespDto != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations() != null && implementConcBhvThemeLockComComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行分布式加锁.防并发上锁情况 等于 空上锁成功)  69530

            QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
            QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto = new QueryRefRedisBusinessDataSetDetailComReqDto();
            queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1846051_1_69540
            queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1846050_1_69540
            queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1846054_1_69540
            queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1846055_1_69540
            if (reqDto != null) {
                queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1(reqDto.getCommPrimaryKeyFieldName());//SimpleFieldAssign//sourceId:1846052_1_69540
                queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1846053_1_69540
            }

            /*D2查上锁后的MQ遥控器当前最小最大值[8476]   */
            Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-Redis数据对象目录不能为空", false);
            Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-业务数据对象不能为空", false);
            Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(), "D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-入参自定义字段1不能为空", false);
            Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(), "D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-入参自定义字段值1不能为空", false);
            Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(), "D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-自定义字段2不能为空", false);
            Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(), "D2执行MQ遥控器重置为0(公共)-D2查上锁后的MQ遥控器当前最小最大值-自定义字段3不能为空", false);
            queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


            ImplementNumericalContrastMagnitudeComRespDto implementNumericalContrastMagnitudeComRespDto = null;
            if (queryRefRedisBusinessDataSetDetailComRespDto != null) {
                ImplementNumericalContrastMagnitudeComReqDto implementNumericalContrastMagnitudeComReqDto = new ImplementNumericalContrastMagnitudeComReqDto();
                if (queryRefRedisBusinessDataSetDetailComRespDto != null) {
                    implementNumericalContrastMagnitudeComReqDto.setCalcPara1(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2() != null ? Double.valueOf(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField2()) : null);//SimpleFieldAssign//sourceId:1846059_1_69541
                    implementNumericalContrastMagnitudeComReqDto.setCalcPara2(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField3() != null ? Double.valueOf(queryRefRedisBusinessDataSetDetailComRespDto.getCustomField3()) : null);//SimpleFieldAssign//sourceId:1846060_1_69541
                }

                /*D2执行两个数值对比大小(公共)[5551]   */
                Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara1(), "D2执行MQ遥控器重置为0(公共)-D2执行两个数值对比大小(公共)-计算入参1不能为空", false);
                Assert.isNull(implementNumericalContrastMagnitudeComReqDto.getCalcPara2(), "D2执行MQ遥控器重置为0(公共)-D2执行两个数值对比大小(公共)-计算入参2不能为空", false);
                implementNumericalContrastMagnitudeComRespDto = interfaceModeService.implementNumericalContrastMagnitudeCom(implementNumericalContrastMagnitudeComReqDto)/*vcase invoke isSameApp*/;


            }
            if ((implementNumericalContrastMagnitudeComRespDto != null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult() != null && implementNumericalContrastMagnitudeComRespDto.getNumCompareResult().equals("LATER"))) {
                //if(D2当前排队最小值与最大值比大小.数值比较结果 等于 之后（大于）)  69542

                UpdateRedisBusinessDataSetComRespDto updateRedisBusinessDataSetComRespDto = null;
                UpdateRedisBusinessDataSetComReqDto updateRedisBusinessDataSetComReqDto = new UpdateRedisBusinessDataSetComReqDto();
                updateRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1845581_1_69543
                updateRedisBusinessDataSetComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1845582_1_69543
                updateRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1845583_1_69543
                updateRedisBusinessDataSetComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1845586_1_69543
                updateRedisBusinessDataSetComReqDto.setCustomFieldValue2("0");//CUSTOM_CONVENTION//sourceId:1845587_1_69543
                updateRedisBusinessDataSetComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1845588_1_69543
                updateRedisBusinessDataSetComReqDto.setCustomFieldValue3("0");//CUSTOM_CONVENTION//sourceId:1845589_1_69543
                updateRedisBusinessDataSetComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1846066_1_69543
                updateRedisBusinessDataSetComReqDto.setCustomFieldValue4("FALSE");//CUSTOM_CONVENTION//sourceId:1846067_1_69543
                if (reqDto != null) {
                    updateRedisBusinessDataSetComReqDto.setRefCustomField1(reqDto.getCommPrimaryKeyFieldName());//SimpleFieldAssign//sourceId:1845584_1_69543
                    updateRedisBusinessDataSetComReqDto.setRefCustomFieldValue1(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1845585_1_69543
                }

                /*D2修改redis业务数据对象(业务原子)[9407]   */
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-Redis数据对象目录不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-业务数据对象不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getIsDataList(), "D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-是否是数据集对象不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomField1(), "D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-入参自定义字段1不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getRefCustomFieldValue1(), "D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-入参自定义字段值1不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField2(), "D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段2不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue2(), "D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段值2不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField3(), "D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段3不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue3(), "D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段值3不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomField4(), "D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段4不能为空", false);
                Assert.isNull(updateRedisBusinessDataSetComReqDto.getCustomFieldValue4(), "D2执行MQ遥控器重置为0(公共)-D2修改redis业务数据对象(业务原子)-自定义字段值4不能为空", false);
                updateRedisBusinessDataSetComRespDto = businessAtomService.updateRedisBusinessDataSetCom(updateRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


            }
            ImplementConcBhvThemeLockComComRespDto implementConcBhvThemeLockComComRespDto_2 = null;
            ImplementConcBhvThemeLockComComReqDto implementConcBhvThemeLockComComReqDto_1 = new ImplementConcBhvThemeLockComComReqDto();
            implementConcBhvThemeLockComComReqDto_1.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1843219_1_69768
            implementConcBhvThemeLockComComReqDto_1.setBehaviorThemeLockCode("MQ_HOVER_QUEUE_LOCK");//sourceId:1843209_1_69768
            implementConcBhvThemeLockComComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1843208_1_69768
            if (reqDto != null) {
                implementConcBhvThemeLockComComReqDto_1.setCommPrimaryKey(reqDto.getCommPrimaryKey());//SimpleFieldAssign//sourceId:1843210_1_69768
            }

            /*D2执行分布式解锁[8388]   */
            Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getRedisDataObjectCatalogue(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式解锁-Redis数据对象目录不能为空", false);
            Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getBehaviorThemeLockCode(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式解锁-行为主题锁业务数据对象不能为空", false);
            Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getCommPrimaryKey(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式解锁-通用主键ID不能为空", false);
            Assert.isNull(implementConcBhvThemeLockComComReqDto_1.getPreventConcurrentLockingUnlocking(), "D2执行MQ遥控器重置为0(公共)-D2执行分布式解锁-防并发上锁or解锁不能为空", false);
            implementConcBhvThemeLockComComRespDto_2 = interfaceModeService.implementConcBhvThemeLockComCom(implementConcBhvThemeLockComComReqDto_1)/*vcase invoke isSameApp*/;


        }
        ImplementRemoteControllerResetZeroComRespDto retData = new ImplementRemoteControllerResetZeroComRespDto();


        return retData;
    }

    /**
     * D2新增规划财务MQ排队(redis)[9695]
     * gen by moon at 7/2/2024, 3:20:08 AM
     */
    @Trace(operationName = "D2新增规划财务MQ排队(redis)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddFinancialPlannMqQueueRedisComRespDto addFinancialPlannMqQueueRedisCom(AddFinancialPlannMqQueueRedisComReqDto reqDto) {


        //步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850958_1
            receptionServiceReq.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1855393_1
            receptionServiceReq.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1855394_1
        }

        /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D2新增规划财务MQ排队(redis)-M2接收入参字段-冗余评价模板ID不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleStartTime(), "D2新增规划财务MQ排队(redis)-M2接收入参字段-更新周期开始时间不能为空", false);
        Assert.isNull(receptionServiceReq.getUpdateCycleEndTime(), "D2新增规划财务MQ排队(redis)-M2接收入参字段-更新周期结束时间不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//步骤1: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto = null;
        ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto = new ImplementTimeFormatConversionComReqDto();
        if (reqDto != null) {
            implementTimeFormatConversionComReqDto.setComTxtField(reqDto.getUpdateCycleStartTime() != null ? String.valueOf(reqDto.getUpdateCycleStartTime()) : "");//SimpleFieldAssign//sourceId:1855389_1
        }

        /*D2更新周期开始时间[9757]   */
        Assert.isNull(implementTimeFormatConversionComReqDto.getComTxtField(), "D2新增规划财务MQ排队(redis)-D2更新周期开始时间-通用文本字段不能为空", false);
        implementTimeFormatConversionComRespDto = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto)/*vcase invoke isSameApp*/;


//步骤2: D2执行时间格式转换(公共) - implementTimeFormatConversionCom
        ImplementTimeFormatConversionComRespDto implementTimeFormatConversionComRespDto_2 = null;
        ImplementTimeFormatConversionComReqDto implementTimeFormatConversionComReqDto_1 = new ImplementTimeFormatConversionComReqDto();
        if (reqDto != null) {
            implementTimeFormatConversionComReqDto_1.setComTxtField(reqDto.getUpdateCycleEndTime() != null ? String.valueOf(reqDto.getUpdateCycleEndTime()) : "");//SimpleFieldAssign//sourceId:1855391_1
        }

        /*D2更新周期结束时间[9757]   */
        Assert.isNull(implementTimeFormatConversionComReqDto_1.getComTxtField(), "D2新增规划财务MQ排队(redis)-D2更新周期结束时间-通用文本字段不能为空", false);
        implementTimeFormatConversionComRespDto_2 = interfaceModeService.implementTimeFormatConversionCom(implementTimeFormatConversionComReqDto_1)/*vcase invoke isSameApp*/;


//步骤3: D2-新增redis业务数据对象（业务原子） - addRedisBusinessDataSetCom
        AddRedisBusinessDataSetComRespDto addRedisBusinessDataSetComRespDto = null;
        if (implementTimeFormatConversionComRespDto != null) {
            AddRedisBusinessDataSetComReqDto addRedisBusinessDataSetComReqDto = new AddRedisBusinessDataSetComReqDto();
            addRedisBusinessDataSetComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1850921_1
            addRedisBusinessDataSetComReqDto.setBusinessDataObject("FINANCIAL_CALC_MQ_QUEUE");//sourceId:1850919_1
            addRedisBusinessDataSetComReqDto.setIsDeleteRedis("FALSE");//sourceId:1850922_1
            addRedisBusinessDataSetComReqDto.setIsDataList("TRUE");//sourceId:1850925_1
            addRedisBusinessDataSetComReqDto.setCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:1850926_1
            addRedisBusinessDataSetComReqDto.setCustomField2("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:1850928_1
            addRedisBusinessDataSetComReqDto.setCustomField3("updateCycleId");//CUSTOM_CONVENTION//sourceId:1850930_1
            addRedisBusinessDataSetComReqDto.setCustomField4("belongToContentId");//CUSTOM_CONVENTION//sourceId:1850932_1
            addRedisBusinessDataSetComReqDto.setCustomField5("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1850934_1
            addRedisBusinessDataSetComReqDto.setCustomField6("spaceId");//CUSTOM_CONVENTION//sourceId:1850936_1
            addRedisBusinessDataSetComReqDto.setCustomField7("accountId");//CUSTOM_CONVENTION//sourceId:1850938_1
            addRedisBusinessDataSetComReqDto.setCustomField8("totalBudgetAmount");//CUSTOM_CONVENTION//sourceId:1850940_1
            addRedisBusinessDataSetComReqDto.setCustomField9("isBudgetAccount");//CUSTOM_CONVENTION//sourceId:1850942_1
            addRedisBusinessDataSetComReqDto.setCustomField10("isIncomingAccount");//CUSTOM_CONVENTION//sourceId:1850944_1
            addRedisBusinessDataSetComReqDto.setCustomField11("isStatisticalAccount");//CUSTOM_CONVENTION//sourceId:1850946_1
            addRedisBusinessDataSetComReqDto.setCustomField13("appId");//CUSTOM_CONVENTION//sourceId:1850954_1
            addRedisBusinessDataSetComReqDto.setCustomField14("operationInductionId");//CUSTOM_CONVENTION//sourceId:1850956_1
            addRedisBusinessDataSetComReqDto.setCustomField12("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:1850952_1
            addRedisBusinessDataSetComReqDto.setCustomField15("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:1851402_1
            addRedisBusinessDataSetComReqDto.setCustomField16("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:1851404_1
            addRedisBusinessDataSetComReqDto.setCustomField17("entityId");//CUSTOM_CONVENTION//sourceId:1915359_1
            if (reqDto != null) {
                addRedisBusinessDataSetComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850920_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue1(reqDto.getCustomFieldValue1());//SimpleFieldAssign//sourceId:1850927_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue2(reqDto.getCustomFieldValue2());//SimpleFieldAssign//sourceId:1850929_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue3(reqDto.getCustomFieldValue3());//SimpleFieldAssign//sourceId:1850931_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue4(reqDto.getCustomFieldValue4());//SimpleFieldAssign//sourceId:1850933_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue5(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850935_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue6(reqDto.getCustomFieldValue6());//SimpleFieldAssign//sourceId:1850937_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue7(reqDto.getCustomFieldValue7());//SimpleFieldAssign//sourceId:1850939_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue8(reqDto.getCustomFieldValue8());//SimpleFieldAssign//sourceId:1850941_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue9(reqDto.getCustomFieldValue9());//SimpleFieldAssign//sourceId:1850943_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue10(reqDto.getCustomFieldValue10());//SimpleFieldAssign//sourceId:1850945_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue11(reqDto.getCustomFieldValue11());//SimpleFieldAssign//sourceId:1850947_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue13(reqDto.getCustomFieldValue13());//SimpleFieldAssign//sourceId:1850955_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue14(reqDto.getCustomFieldValue14());//SimpleFieldAssign//sourceId:1850957_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue16(reqDto.getCustomFieldValue16());//SimpleFieldAssign//sourceId:1851405_1
                addRedisBusinessDataSetComReqDto.setCustomFieldValue17(reqDto.getCustomFieldValue17());//SimpleFieldAssign//sourceId:1915360_1
            }
            if (implementTimeFormatConversionComRespDto != null) {
                addRedisBusinessDataSetComReqDto.setCustomFieldValue12(implementTimeFormatConversionComRespDto.getComTxtField());//SimpleFieldAssign//sourceId:1850953_1
            }
            if (implementTimeFormatConversionComRespDto_2 != null) {
                addRedisBusinessDataSetComReqDto.setCustomFieldValue15(implementTimeFormatConversionComRespDto_2.getComTxtField());//SimpleFieldAssign//sourceId:1851403_1
            }

            /*D2-新增redis业务数据对象（业务原子）[8399]   */
            Assert.isNull(addRedisBusinessDataSetComReqDto.getRedisDataObjectCatalogue(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-Redis数据对象目录不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getBusinessDataObject(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-业务数据对象不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getDataObjectBatchCode(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-数据对象批次标识不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDeleteRedis(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-是否删除redis历史数据不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getIsDataList(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-是否是数据集对象不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField1(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段1不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue1(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值1不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField2(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段2不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField3(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段3不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue3(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值3不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField4(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段4不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue4(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值4不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField5(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段5不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue5(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值5不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField6(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段6不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue6(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值6不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField7(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段7不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue7(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值7不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField8(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段8不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue8(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值8不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField9(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段9不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue9(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值9不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField10(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段10不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField11(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段11不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue11(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值11不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField13(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段13不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue13(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值13不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField14(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段14不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue14(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值14不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField12(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段12不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue12(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值12不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField15(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段15不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue15(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值15不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField16(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段16不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue16(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值16不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomField17(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段17不能为空", false);
            Assert.isNull(addRedisBusinessDataSetComReqDto.getCustomFieldValue17(), "D2新增规划财务MQ排队(redis)-D2-新增redis业务数据对象（业务原子）-自定义字段值17不能为空", false);
            addRedisBusinessDataSetComRespDto = businessAtomService.addRedisBusinessDataSetCom(addRedisBusinessDataSetComReqDto)/*vcase invoke isSameApp*/;


        }

        AddFinancialPlannMqQueueRedisComRespDto retData = new AddFinancialPlannMqQueueRedisComRespDto();


        return retData;
    }

    /**
     * D2执行规划财务MQ排队(redis)[9742]
     * gen by moon at 7/2/2024, 3:20:15 AM
     */
    @Trace(operationName = "D2执行规划财务MQ排队(redis)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public ImplementFinancialPlannMqQueueComRespDto implementFinancialPlannMqQueueCom(ImplementFinancialPlannMqQueueComReqDto reqDto) {


        //virtualUsage D2执行并发行为主题锁(悬停等待)-上锁  69662
        ImplementConcurrencyBehaviorThemeLockWaitComRespDto implementConcurrencyBehaviorThemeLockWaitComRespDto = null;
        ImplementConcurrencyBehaviorThemeLockWaitComReqDto implementConcurrencyBehaviorThemeLockWaitComReqDto = new ImplementConcurrencyBehaviorThemeLockWaitComReqDto();
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1850594_1_69662
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setBusinessDataObject("MQ_HOVER_QUEUE_LOCK");//sourceId:1850595_1_69662
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setPreventConcurrentLockingUnlocking("LOCK");//sourceId:1850597_1_69662
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setWaitingTime("10");//CUSTOM_CONVENTION//sourceId:1850598_1_69662
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setWaitTimeUnitType("MINUTES");//sourceId:1850599_1_69662
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setDuration(Long.valueOf(15));//CUSTOM_CONVENTION//sourceId:1850600_1_69662
        implementConcurrencyBehaviorThemeLockWaitComReqDto.setTimeUnitType("MINUTES");//sourceId:1850601_1_69662
        if (reqDto != null) {
            implementConcurrencyBehaviorThemeLockWaitComReqDto.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850596_1_69662
        }

        /*D2执行并发行为主题锁(悬停等待)-上锁[9699]   */
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getRedisDataObjectCatalogue(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-Redis数据对象目录不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getBusinessDataObject(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-业务数据对象不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getDataObjectBatchCode(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-数据对象批次标识不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getPreventConcurrentLockingUnlocking(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-防并发上锁or解锁不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getWaitingTime(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-等待时长不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getWaitTimeUnitType(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-等待时间单位类型不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getDuration(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-锁定时长不能为空", false);
        Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto.getTimeUnitType(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-上锁-时间单位类型不能为空", false);
        implementConcurrencyBehaviorThemeLockWaitComRespDto = interfaceModeService.implementConcurrencyBehaviorThemeLockWaitCom(implementConcurrencyBehaviorThemeLockWaitComReqDto)/*vcase invoke isSameApp*/;


        if ((implementConcurrencyBehaviorThemeLockWaitComRespDto != null && implementConcurrencyBehaviorThemeLockWaitComRespDto.getPreventConcurrentLockingSituations() != null && implementConcurrencyBehaviorThemeLockWaitComRespDto.getPreventConcurrentLockingSituations().equals("EMPTY_LOCK_SUCCESSFUL"))) {
            //if(D2执行并发行为主题锁(悬停等待)-上锁.防并发上锁情况 等于 空上锁成功)  69663

            UpdateRemoteControllerMqQueueComRespDto updateRemoteControllerMqQueueComRespDto = null;
            UpdateRemoteControllerMqQueueComReqDto updateRemoteControllerMqQueueComReqDto = new UpdateRemoteControllerMqQueueComReqDto();
            updateRemoteControllerMqQueueComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1850778_1_69664
            if (reqDto != null) {
                updateRemoteControllerMqQueueComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850779_1_69664
            }

            /*D2遥控器MQ排队(修改单条redis)[9693]   */
            Assert.isNull(updateRemoteControllerMqQueueComReqDto.getBusinessDataObject(), "D2执行规划财务MQ排队(redis)-D2遥控器MQ排队(修改单条redis)-业务数据对象不能为空", false);
            Assert.isNull(updateRemoteControllerMqQueueComReqDto.getEvaluationTemplateId(), "D2执行规划财务MQ排队(redis)-D2遥控器MQ排队(修改单条redis)-冗余评价模板ID不能为空", false);
            updateRemoteControllerMqQueueComRespDto = updateRemoteControllerMqQueueCom(updateRemoteControllerMqQueueComReqDto)/*vcase invoke 同服务,同domain*/;


            if ((updateRemoteControllerMqQueueComRespDto != null && updateRemoteControllerMqQueueComRespDto.getQueueMinimum() != null && updateRemoteControllerMqQueueComRespDto != null && updateRemoteControllerMqQueueComRespDto.getQueueMaximum() != null)) {
                //if((D2遥控器MQ排队(修改单条redis).排队最小值 值不等于空  and D2遥控器MQ排队(修改单条redis).排队最大值 值不等于空 ))  69665

                AddFinancialPlannMqQueueRedisComRespDto addFinancialPlannMqQueueRedisComRespDto = null;
                if (updateRemoteControllerMqQueueComRespDto != null) {
                    AddFinancialPlannMqQueueRedisComReqDto addFinancialPlannMqQueueRedisComReqDto = new AddFinancialPlannMqQueueRedisComReqDto();
                    addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue13(CommonFunctionHelper.getBaseInfoFromLocal().getSpecAppId());//CURRENT_APPID//sourceId:1850986_1_69666
                    addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue14(CommonFunctionHelper.getBaseInfoFromLocal().getSpecInductionRecordId());//CURRENT_INDUCTIONID//sourceId:1850987_1_69666
                    if (updateRemoteControllerMqQueueComRespDto != null) {
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue1(updateRemoteControllerMqQueueComRespDto.getQueueMaximum() != null ? String.valueOf(updateRemoteControllerMqQueueComRespDto.getQueueMaximum()) : "");//SimpleFieldAssign//sourceId:1850975_1_69666
                    }
                    if (reqDto != null) {
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue2(reqDto.getPreUpdateCycleId());//SimpleFieldAssign//sourceId:1850976_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue3(reqDto.getUpdateCycleId());//SimpleFieldAssign//sourceId:1851440_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setUpdateCycleStartTime(reqDto.getUpdateCycleStartTime());//SimpleFieldAssign//sourceId:1855397_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setUpdateCycleEndTime(reqDto.getUpdateCycleEndTime());//SimpleFieldAssign//sourceId:1855398_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue16(reqDto.getUpdateCycleTypeCode());//SimpleFieldAssign//sourceId:1851409_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue4(reqDto.getBelongToContentId());//SimpleFieldAssign//sourceId:1850978_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue17(reqDto.getEntityId());//SimpleFieldAssign//sourceId:1915362_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850974_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue6(reqDto.getSpaceId());//SimpleFieldAssign//sourceId:1850979_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue7(reqDto.getAccountId());//SimpleFieldAssign//sourceId:1850980_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue8(reqDto.getTotalBudgetAmount() != null ? String.valueOf(reqDto.getTotalBudgetAmount()) : "");//SimpleFieldAssign//sourceId:1850981_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue9(reqDto.getIsBudgetAccount());//SimpleFieldAssign//sourceId:1850982_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue10(reqDto.getIsIncomingAccount());//SimpleFieldAssign//sourceId:1850983_1_69666
                        addFinancialPlannMqQueueRedisComReqDto.setCustomFieldValue11(reqDto.getIsStatisticalAccount());//SimpleFieldAssign//sourceId:1850984_1_69666
                    }

                    /*D2新增规划财务MQ排队(redis)[9695]   */
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue1(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-排队值不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue3(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-更新周期ID不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getUpdateCycleStartTime(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-更新周期开始时间不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getUpdateCycleEndTime(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-更新周期结束时间不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue16(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-更新周期类型标识不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue4(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-数据归属内容表主键ID不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue17(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-归属内容表主键ID不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getEvaluationTemplateId(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-冗余评价模板ID不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue6(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-空间ID不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue7(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-账户ID不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue8(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-累计收入金额不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue9(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-是否预算账户不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue11(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-是否统计账户不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue13(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-联盟应用ID不能为空", false);
                    Assert.isNull(addFinancialPlannMqQueueRedisComReqDto.getCustomFieldValue14(), "D2执行规划财务MQ排队(redis)-D2新增规划财务MQ排队(redis)-操作人就职记录ID不能为空", false);
                    addFinancialPlannMqQueueRedisComRespDto = addFinancialPlannMqQueueRedisCom(addFinancialPlannMqQueueRedisComReqDto)/*vcase invoke 同服务,同domain*/;


                }
            }
            ImplementConcurrencyBehaviorThemeLockWaitComRespDto implementConcurrencyBehaviorThemeLockWaitComRespDto_2 = null;
            ImplementConcurrencyBehaviorThemeLockWaitComReqDto implementConcurrencyBehaviorThemeLockWaitComReqDto_1 = new ImplementConcurrencyBehaviorThemeLockWaitComReqDto();
            implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1850784_1_69668
            implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setBusinessDataObject("MQ_HOVER_QUEUE_LOCK");//sourceId:1850785_1_69668
            implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setPreventConcurrentLockingUnlocking("UNLOCK");//sourceId:1850787_1_69668
            if (reqDto != null) {
                implementConcurrencyBehaviorThemeLockWaitComReqDto_1.setDataObjectBatchCode(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1850786_1_69668
            }

            /*D2执行并发行为主题锁(悬停等待)-解锁[9699]   */
            Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getRedisDataObjectCatalogue(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-解锁-Redis数据对象目录不能为空", false);
            Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getBusinessDataObject(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-解锁-业务数据对象不能为空", false);
            Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getDataObjectBatchCode(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-解锁-数据对象批次标识不能为空", false);
            Assert.isNull(implementConcurrencyBehaviorThemeLockWaitComReqDto_1.getPreventConcurrentLockingUnlocking(), "D2执行规划财务MQ排队(redis)-D2执行并发行为主题锁(悬停等待)-解锁-防并发上锁or解锁不能为空", false);
            implementConcurrencyBehaviorThemeLockWaitComRespDto_2 = interfaceModeService.implementConcurrencyBehaviorThemeLockWaitCom(implementConcurrencyBehaviorThemeLockWaitComReqDto_1)/*vcase invoke isSameApp*/;


        }
        ImplementFinancialPlannMqQueueComRespDto retData = new ImplementFinancialPlannMqQueueComRespDto();


        return retData;
    }

    /**
     * D2查询规划财务MQ排队详情(公共)[9745]
     * gen by moon at 7/2/2024, 3:20:22 AM
     */
    @Trace(operationName = "D2查询规划财务MQ排队详情(公共)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryFinancialPlannMqQueueDetailComRespDto queryFinancialPlannMqQueueDetailCom(QueryFinancialPlannMqQueueDetailComReqDto reqDto) {


        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 = null;
//步骤0: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
        QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto = new QueryRefRedisBusinessDataSetDetailComReqDto();
        queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1851582_1
        queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("queueNum");//CUSTOM_CONVENTION//sourceId:1851584_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField1("preUpdateCycleId");//CUSTOM_CONVENTION//sourceId:1851586_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("updateCycleId");//CUSTOM_CONVENTION//sourceId:1851587_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("updateCycleStartTime");//CUSTOM_CONVENTION//sourceId:1851588_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField4("updateCycleEndTime");//CUSTOM_CONVENTION//sourceId:1851589_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField5("updateCycleTypeCode");//CUSTOM_CONVENTION//sourceId:1851590_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField6("belongToContentId");//CUSTOM_CONVENTION//sourceId:1851591_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField7("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1851592_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField8("spaceId");//CUSTOM_CONVENTION//sourceId:1851593_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField9("accountId");//CUSTOM_CONVENTION//sourceId:1851594_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField10("totalBudgetAmount");//CUSTOM_CONVENTION//sourceId:1851595_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField11("isBudgetAccount");//CUSTOM_CONVENTION//sourceId:1851596_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField12("isIncomingAccount");//CUSTOM_CONVENTION//sourceId:1851597_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField13("isStatisticalAccount");//CUSTOM_CONVENTION//sourceId:1851598_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField14("appId");//CUSTOM_CONVENTION//sourceId:1851660_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField15("operationInductionId");//CUSTOM_CONVENTION//sourceId:1851661_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField16("entityId");//CUSTOM_CONVENTION//sourceId:1915372_1
        if (reqDto != null) {
            queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1851581_1
            queryRefRedisBusinessDataSetDetailComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1851583_1
            queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getRefCustomFieldValue1());//SimpleFieldAssign//sourceId:1851585_1
        }

        /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getDataObjectBatchCode(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-数据对象批次标识不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField1(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段2不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段3不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField4(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段4不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField5(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段5不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField6(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段6不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField7(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段7不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField8(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段8不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField9(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段9不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField10(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段10不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField11(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段11不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField12(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段12不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField13(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段13不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField14(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段14不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField15(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段15不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField16(), "D2查询规划财务MQ排队详情(公共)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段16不能为空", false);
        queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


        queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

        QueryFinancialPlannMqQueueDetailComRespDto retData = new QueryFinancialPlannMqQueueDetailComRespDto();
        if (queryRefRedisBusinessDataSetDetailComRespDto_1 != null) {
            retData.setPreUpdateCycleId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField1());//SimpleFieldAssign//sourceId:1851615_1
            retData.setUpdateCycleId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField2());//SimpleFieldAssign//sourceId:1851616_1
            retData.setUpdateCycleStartTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField3());//SimpleFieldAssign//sourceId:1855379_1
            retData.setUpdateCycleEndTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField4());//SimpleFieldAssign//sourceId:1855380_1
            retData.setUpdateCycleTypeCode(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField5());//SimpleFieldAssign//sourceId:1851619_1
            retData.setBelongToContentId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField6());//SimpleFieldAssign//sourceId:1851620_1
            retData.setEvaluationTemplateId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField7());//SimpleFieldAssign//sourceId:1851621_1
            retData.setSpaceId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField8());//SimpleFieldAssign//sourceId:1851622_1
            retData.setAccountId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField9());//SimpleFieldAssign//sourceId:1851623_1
            retData.setTotalBudgetAmount(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField10());//SimpleFieldAssign//sourceId:1851624_1
            retData.setIsBudgetAccount(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField11());//SimpleFieldAssign//sourceId:1851625_1
            retData.setIsIncomingAccount(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField12());//SimpleFieldAssign//sourceId:1851626_1
            retData.setIsStatisticalAccount(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField13());//SimpleFieldAssign//sourceId:1851627_1
            retData.setAppId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField14());//SimpleFieldAssign//sourceId:1851664_1
            retData.setOperationInductionId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField15());//SimpleFieldAssign//sourceId:1851665_1
            retData.setEntityId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField16());//SimpleFieldAssign//sourceId:1915374_1
        }


        return retData;
    }

    /**
     * D2新增公共字段(推内存)[9752]
     * gen by moon at 6/6/2024, 3:48:43 PM
     */
    @Trace(operationName = "D2新增公共字段(推内存)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public AddCommonDataComRespDto addCommonDataCom(AddCommonDataComReqDto reqDto) {


        //步骤0: D2新增内存业务数据(业务原子) - addMemoryBusiness2DataCom
        AddMemoryBusiness2DataComRespDto addMemoryBusiness2DataComRespDto = null;
        AddMemoryBusiness2DataComReqDto addMemoryBusiness2DataComReqDto = new AddMemoryBusiness2DataComReqDto();
        addMemoryBusiness2DataComReqDto.setIsDataList("FALSE");//sourceId:1852616_1
        addMemoryBusiness2DataComReqDto.setCustomField1("spaceId");//CUSTOM_CONVENTION//sourceId:1852617_1
        addMemoryBusiness2DataComReqDto.setCustomField2("appId");//CUSTOM_CONVENTION//sourceId:1852619_1
        addMemoryBusiness2DataComReqDto.setCustomField3("operationInductionId");//CUSTOM_CONVENTION//sourceId:1852621_1
        if (reqDto != null) {
            addMemoryBusiness2DataComReqDto.setDataObjectBatchCode(reqDto.getDataObjectBatchCode());//SimpleFieldAssign//sourceId:1852614_1
            addMemoryBusiness2DataComReqDto.setBusinessDataObject(reqDto.getBusinessDataObject());//SimpleFieldAssign//sourceId:1852615_1
            addMemoryBusiness2DataComReqDto.setCustomFieldValue1(reqDto.getCustomFieldValue1());//SimpleFieldAssign//sourceId:1852618_1
            addMemoryBusiness2DataComReqDto.setCustomFieldValue2(reqDto.getCustomFieldValue2());//SimpleFieldAssign//sourceId:1852620_1
            addMemoryBusiness2DataComReqDto.setCustomFieldValue3(reqDto.getCustomFieldValue3());//SimpleFieldAssign//sourceId:1852622_1
        }

        /*D2新增内存业务数据(业务原子)[9751]   */
        Assert.isNull(addMemoryBusiness2DataComReqDto.getDataObjectBatchCode(), "D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-数据对象批次标识不能为空", false);
        Assert.isNull(addMemoryBusiness2DataComReqDto.getBusinessDataObject(), "D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-业务数据对象不能为空", false);
        Assert.isNull(addMemoryBusiness2DataComReqDto.getIsDataList(), "D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-是否是数据集对象不能为空", false);
        Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomField1(), "D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段1不能为空", false);
        Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomFieldValue1(), "D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段值1不能为空", false);
        Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomField2(), "D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段2不能为空", false);
        Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomFieldValue2(), "D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段值2不能为空", false);
        Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomField3(), "D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段3不能为空", false);
        Assert.isNull(addMemoryBusiness2DataComReqDto.getCustomFieldValue3(), "D2新增公共字段(推内存)-D2新增内存业务数据(业务原子)-自定义字段值3不能为空", false);
        addMemoryBusiness2DataComRespDto = businessAtomService.addMemoryBusiness2DataCom(addMemoryBusiness2DataComReqDto)/*vcase invoke isSameApp*/;


        AddCommonDataComRespDto retData = new AddCommonDataComRespDto();


        return retData;
    }

    /**
     * D2查询规划财务MQ遥控器详情(redis)[9786]
     * gen by moon at 7/2/2024, 3:20:28 AM
     */
    @Trace(operationName = "D2查询规划财务MQ遥控器详情(redis)")
    @Tags({@Tag(key = "参数", value = "arg[0]"),
            @Tag(key = "返回值", value = "returnedObj")})
    @Transactional(rollbackFor = Exception.class)
    @Override
    public QueryFinancialPlannMqRemoteControllerDetailComRespDto queryFinancialPlannMqRemoteControllerDetailCom(QueryFinancialPlannMqRemoteControllerDetailComReqDto reqDto) {


        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto_1 = null;
//步骤0: M2执行第十接收字段（特殊方法） - implementTenReceivingField
        //ModelCode: receptionService
        ImplementTenReceivingFieldRespDto receptionServiceRes = null;
        ImplementTenReceivingFieldReqDto receptionServiceReq = new ImplementTenReceivingFieldReqDto();
        if (reqDto != null) {
            receptionServiceReq.setEvaluationTemplateId(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1861769_1
        }

        /*M2接收入参字段[8782]  用于特殊方法接收上游入参。 */
        Assert.isNull(receptionServiceReq.getEvaluationTemplateId(), "D2查询规划财务MQ遥控器详情(redis)-M2接收入参字段-冗余评价模板ID不能为空", false);
        receptionServiceRes = nbEvaCalc.implementTenReceivingField(receptionServiceReq);


//步骤1: D2-查询入参redis业务数据对象详情（业务原子） - queryRefRedisBusinessDataSetDetailCom
        QueryRefRedisBusinessDataSetDetailComRespDto queryRefRedisBusinessDataSetDetailComRespDto = null;
        QueryRefRedisBusinessDataSetDetailComReqDto queryRefRedisBusinessDataSetDetailComReqDto = new QueryRefRedisBusinessDataSetDetailComReqDto();
        queryRefRedisBusinessDataSetDetailComReqDto.setRedisDataObjectCatalogue("MQ遥控器");//sourceId:1861571_1
        queryRefRedisBusinessDataSetDetailComReqDto.setBusinessDataObject("MQ_REMOTE_CONTROLLER");//sourceId:1861570_1
        queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1861572_1
        queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomField2("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1861772_1
        queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue2("FINANCIAL_PLAN");//CUSTOM_CONVENTION//sourceId:1861773_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField1("evaluationTemplateId");//CUSTOM_CONVENTION//sourceId:1861574_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField2("queueMinimum");//CUSTOM_CONVENTION//sourceId:1861575_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField3("queueMaximum");//CUSTOM_CONVENTION//sourceId:1861576_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField4("isQueueCurrently");//CUSTOM_CONVENTION//sourceId:1861577_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField5("mqRemoteControllerName");//CUSTOM_CONVENTION//sourceId:1861578_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField6("operationInductionId");//CUSTOM_CONVENTION//sourceId:1861579_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField7("operateTime");//CUSTOM_CONVENTION//sourceId:1861580_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField8("isOpenFundsArrival");//CUSTOM_CONVENTION//sourceId:1861581_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField9("cashAccountUnit");//CUSTOM_CONVENTION//sourceId:1861582_1
        queryRefRedisBusinessDataSetDetailComReqDto.setCustomField10("cycleMode");//CUSTOM_CONVENTION//sourceId:1915606_1
        if (reqDto != null) {
            queryRefRedisBusinessDataSetDetailComReqDto.setRefCustomFieldValue1(reqDto.getEvaluationTemplateId());//SimpleFieldAssign//sourceId:1861573_1
        }

        /*D2-查询入参redis业务数据对象详情（业务原子）[8476]   */
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRedisDataObjectCatalogue(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-Redis数据对象目录不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getBusinessDataObject(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-业务数据对象不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField1(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue1(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomField2(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段2不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getRefCustomFieldValue2(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-入参自定义字段值2不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField1(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段1不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField2(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段2不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField3(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段3不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField4(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段4不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField5(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段5不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField6(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段6不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField7(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段7不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField8(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段8不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField9(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段9不能为空", false);
        Assert.isNull(queryRefRedisBusinessDataSetDetailComReqDto.getCustomField10(), "D2查询规划财务MQ遥控器详情(redis)-D2-查询入参redis业务数据对象详情（业务原子）-自定义字段10不能为空", false);
        queryRefRedisBusinessDataSetDetailComRespDto = businessAtomService.queryRefRedisBusinessDataSetDetailCom(queryRefRedisBusinessDataSetDetailComReqDto)/*vcase invoke isSameApp*/;


        queryRefRedisBusinessDataSetDetailComRespDto_1 = queryRefRedisBusinessDataSetDetailComRespDto;

        QueryFinancialPlannMqRemoteControllerDetailComRespDto retData = new QueryFinancialPlannMqRemoteControllerDetailComRespDto();
        if (queryRefRedisBusinessDataSetDetailComRespDto_1 != null) {
            retData.setEvaluationTemplateId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField1());//SimpleFieldAssign//sourceId:1861783_1
            retData.setQueueMinimum(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField2());//SimpleFieldAssign//sourceId:1861784_1
            retData.setQueueMaximum(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField3());//SimpleFieldAssign//sourceId:1861785_1
            retData.setIsQueueCurrently(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField4());//SimpleFieldAssign//sourceId:1861786_1
            retData.setMqRemoteControllerName(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField5());//SimpleFieldAssign//sourceId:1861787_1
            retData.setOperationInductionId(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField6());//SimpleFieldAssign//sourceId:1861788_1
            retData.setOperateTime(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField7());//SimpleFieldAssign//sourceId:1861789_1
            retData.setIsOpenFundsArrival(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField8());//SimpleFieldAssign//sourceId:1861790_1
            retData.setCashAccountUnit(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField9());//SimpleFieldAssign//sourceId:1861791_1
            retData.setPeriodicModeTypeCode(queryRefRedisBusinessDataSetDetailComRespDto_1.getCustomField10());//SimpleFieldAssign//sourceId:1915608_1
        }


        return retData;
    }
    //
}
